Group items tagged

"ScalaTags is a small XML/HTML construction library for Scala. The core functionality of Scalatags is less than 200 lines of code, and yet it provides all the functionality of large frameworks like Python's Jinja2 or C#'s Razor. It does this by leveraging the functionality of the Scala language to do almost everything. A lot of different language constructs can be used to help keep your templates concise and DRY, and why re-invent them all yourself when you have someone else who has done it before you."

"This is a maven plugin that adds a new packaging type ('scala-jar') to maven with a better default lifecycle. This lifecycle binds net.alchim31.maven:scala-maven-plugin:compile to the 'compile' phase by default while also retaining an invocation of maven-compiler-plugin. Additionally, com.vast:scala-surefire-maven-plugin:test is bound to the 'test' phase. This allows native and seamless use of ScalaTest in your build."

"The Neo4j Scala wrapper library allows you the Neo4j open source graph database through a domain-specific simplified language."

This milestone ships with a whole lot of new features for you to try out: implicit highlight, move refactoring, scala debugger and semantic highlight are the most exciting ones. If you are like us, once you start using them you will no longer be able go back. They are simply too addictive!

Graham Tackley discusses how The Guardian switched all new development from Java to Scala, why they did that, what were the benefits and the problems, and why they did not choose Python+Django.

Una explicación bastante concisa de varianza, covarianza y contravarianza en el sistema de tipado de scala.

Reactive-web is a new framework for writing highly interactive and dynamic web applications. It's written in Scala , sits on top of Lift, and uses the Functional Reactive Programming library reactive-core (it's in the same repository). As in GWT, you can code the user interface in the same language as the rest of your application (except in Scala instead of Java), rather than writing JavaScript. Unlike GWT, however, you don't need an extra build step to convert your code to JavaScript. You can easily combine code that runs on the browser with code that runs on the server. And, you can declare dynamic relationships between components, like binding in Flex/JavaFX/etc. (only much more powerful).

Assessing the effect of different programming languages and programming styles on programmer productivity is of critical interest. In his paper, Gilles Dubochet, describes how he investigated two aspects of programming style using eye movement tracking. He found that it is, on average, 30% faster to comprehend algorithms that use for-comprehensions and maps, as in Scala, rather than those with the iterative while-loops of Java.

"These are the major new features added since Slick 1.0.1: A code generator that reverse-engineers the database schema and generates all code required for working with Slick. New driver architecture to allow support for non-SQL, non-JDBC databases. Table definitions in the Lifted Embedding use a new syntax which is slightly more verbose but also more robust and logical, avoiding several pitfalls from earlier versions. Table definitions (and their * projections) are not restricted to flat tuples of columns anymore. They can use any type that would be valid as the return type of a Query. The old projection concatenation methods ~ and ~: are still supported but not imported by default. In addition to Scala tuples, Slick supports its own HList abstraction for records of arbitrary size. You can also add support for your own record types with only a few lines of code. All record types can be used everywhere (including table definitions and mapped projections) and they can be mixed and nested arbitrarily. Soft inserts are now the default, i.e. AutoInc columns are automatically skipped when inserting with +=, ++=, insert and insertAll. This means that you no longer need separate projections (without the primary key) for inserts. There are separate methods forceInsert and forceInsertAll in JdbcProfile for the old behavior. A new model for pre-compiled queries replaces the old QueryTemplate abstraction. Any query (both, actual collection-valued Query objects and scalar queries) or function from Column types to such a query can now be lifted into a Compiled wrapper. Lifted functions can be applied (without having to recompile the query), and you can use both monadic composition of Compiled values or just get the underlying query and use that for further composition. Pre-compiled queries can now be used for update and delete operations in addition to querying. threadLocalSession has been renamed to dynamicSession and the corresponding methods have distinct names (e.g. w

"Elastic4s is a concise, idiomatic, type safe Scala Client for ElasticSearch. It provides a full Scala DSL to construct your queries and (hopefully!) reducing errors. Due to its typesafe nature Elastic4s is also a good way to learn the options available for any operation, as your IDE can use the type information to show you what methods are available. Elastic4s also allows you to index JSON documents from standard JSON libraries such as Jackson without having to unmarshall."

"Scala macro that produces JavaScript from Scala code."

"Scalaz is a Scala library for functional programming. It provides purely functional data structures to complement those from the Scala standard library. It defines a set of foundational type classes (e.g. Functor, Monad) and corresponding instances for a large number of data structures."

"HPaste unlocks the rich functionality of HBase for a Scala audience. In so doing, it attempts to achieve the following goals: Provide a strong, clear syntax for querying and filtration Perform as fast as possible while maintaining idiomatic Scala client code -- the abstractions should not show up in a profiler! Re-articulate HBase's data structures rather than force it into an ORM-style atmosphere. A rich set of base classes for writing MapReduce jobs in hadoop against HBase tables. Provide a maximum amount of code re-use between general Hbase client usage, and operation from within a MapReduce job. Use Scala's type system to its advantage--the compiler should verify the integrity of the schema. Be a verbose DSL--minimize boilerplate code, but be human readable!"

"In this talk you will learn about a modern way of designing applications that's very different from the traditional approach of building monolithic applications that persist mutable domain objects in a relational database.We will talk about the microservice architecture, it's benefits and drawbacks and how Spring Boot can help. You will learn about implementing business logic using functional, immutable domain models written in Scala. We will describe event sourcing and how it's an extremely useful persistence mechanism for persisting functional domain objects in a microservices architecture."

"Figaro is a probabilistic programming language that supports development of very rich probabilistic models and provides reasoning algorithms that can be applied to models to draw useful conclusions from evidence. Both model representation and reasoning algorithm development can be challenging tasks. Figaro makes it possible to express probabilistic models using the power of programming languages, giving the modeler the expressive tools to create a wide variety of models. Figaro comes with a number of built-in reasoning algorithms that can be applied automatically to new models. In addition, Figaro models are data structures in the Scala programming language, which is interoperable with Java, and can be constructed, manipulated, and used directly within any Scala or Java program."

"A community driven list of useful Scala libraries, frameworks and software."

"Type-safe off-heap memory for Scala."