Group items tagged

"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

"Protostuff is the stuff that leverages google's protobuf. A serialization library with built-in support for forward-backward compatibility (schema evolution) and validation. available formats: protostuff (native) graph (protostuff with support for cyclic references. See SerializingObjectGraphs) protobuf json smile (binary json useable from the protostuff-json module) xml yaml (ser only) kvp (binary uwsgi header) support for messages that are generated by the protostuff-compiler (java_bean) cyclic references via graph format see CompilerOptions for more customized compilation of .proto files support for existing pojos (See runtime schemas) cyclic references via graph format polymorphic (a nested message can be an interface/abstract class or even java.lang.Object) support for existing protoc-generated java messages see the io instructions for json, xml, yaml) no support for cyclic references (limitation of the builder pattern) Interoperability across various mobile platforms android kindle j2me (protostuff-me module) Transcoding support converts one encoding to another. See PipeUsage. Source and Sink protostuff, protobuf, json, json-numeric, smile, smile-numeric, xml Sink only yaml "

Spire is a numeric library for Scala which is intended to be generic, fast, and precise. Using features such as specialization, macros, type classes, and implicits, Spire works hard to defy conventional wisdom around performance and precision trade-offs. A major goal is to allow developers to write efficient numeric code without having to "bake in" particular numeric representations. In most cases, generic implementations using Spire's specialized type classes perform identically to corresponding direct implementations.

shapeless is an exploration of generic (aka polytypic) programming in Scala derived from the various talks I've given over the course of 2011 on implementing scrap your boilerplate and higher rank polymorphism in Scala.

"Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions. Configuration files describe to Terraform the components needed to run a single application or your entire datacenter. Terraform generates an execution plan describing what it will do to reach the desired state, and then executes it to build the described infrastructure. As the configuration changes, Terraform is able to determine what changed and create incremental execution plans which can be applied. The infrastructure Terraform can manage includes low-level components such as compute instances, storage, and networking, as well as high-level components such as DNS entries, SaaS features, etc. The key features of Terraform are: Infrastructure as Code: Infrastructure is described using a high-level configuration syntax. This allows a blueprint of your datacenter to be versioned and treated as you would any other code. Additionally, infrastructure can be shared and re-used. Execution Plans: Terraform has a "planning" step where it generates an execution plan. The execution plan shows what Terraform will do when you call apply. This lets you avoid any surprises when Terraform manipulates infrastructure. Resource Graph: Terraform builds a graph of all your resources, and parallelizes the creation and modification of any non-dependent resources. Because of this, Terraform builds infrastructure as efficiently as possible, and operators get insight into dependencies in their infrastructure. Change Automation: Complex changesets can be applied to your infrastructure with minimal human interaction. With the previously mentioned execution plan and resource graph, you know exactly what Terraform will change and in what order, avoiding many possible human errors."

"shapeless is a type class and dependent type based generic programming library for Scala."

"Babel is a JavaScript compiler. Use next generation JavaScript, today."

"Instead of giving you a single favicon.ico file, RealFaviconGenerator generates all the pictures and HTML code you need to get a cool, mobile- and tablet-ready favicon."

"Command pigeon generates parsers in Go from a PEG grammar."

"general purpose extensions to golang's database/sql "

"Bandicoot is an open source programming system with a new set-based programming language, persistency capabilities, and run-time environment. The language is similar to general purpose programming languages where you write functions/methods and access data through variables. Though, in Bandicoot, you always manipulate data in sets using a small set-based algebra (the relational algebra)." "Here are the main features:   - functions are automatically exposed via HTTP using CSV for data, e.g. /List, /Append  - supports persistency via global variables (with transactions and ACID)  - can run on multiple computers to scale up the read throughput  - built in operators from the relational algebra with a simple syntax, e.g. "+" (union), "-" (minus)  - small binary ~100KB"

General Responsibility Assignment Software Patterns (or Principles), abbreviated GRASP, consists of guidelines for assigning responsibility to classes and objects in object-oriented design.

"sigma.js is an open-source lightweight JavaScript library to draw graphs, using the HTML canvas element. It has been especially designed to: Display interactively static graphs exported from a graph visualization software - like Gephi Display dynamically graphs that are generated on the fly"

This article is a basic list of best practices that our Grails projects follow, gathered from mailing lists, Stack Overflow, blogs, podcasts and internal discussions at IntelliGrape.

A core framework and next-generation shell for tooling and automation at a command line level; with APIs for integration in IDEs, extending built in functionality with plugins, and scripting for automating repetitive tasks, Forge is a tool every open-source developer should be looking at. A core framework for rapid-application development in a standards-based environment. Plugins / incremental project enhancement for Java EE, and more.

Scala macros to generate wiring code for class instantiation. DI (e.g. guice) container replacement.

"Datomic is a distributed database designed to enable scalable, flexible and intelligent applications, running on next-generation cloud architectures. It does this by: Bringing declarative data manipulation into the application, and the data with it Getting time, process and perception right Process (writes) require coordination Perception (reads) require none The past doesn't change Leveraging immutability, and a sound model of state Datomic has: ACID Transactions Joins A sound data model A logical query language - Datalog Thus, Datomic avoids the compromises and losses of many NoSQL solutions. In addition, it offers flexibility and power over the traditional model in supporting: Hierarchy Multi-valued attributes Minimal schema Reliable operation on unreliable, ephemeral cloud instances Time Datomic avoids manual caching and replication, complex configuration, sharding (automatic or manual), logging, locking, latching and disk management of traditional servers."

"JSON Processing project is the open source reference implementation of JSR 353 - Java API for JSON Processing. The JSR provides portable APIs to parse, generate, transform, and query JSON using the streaming API or the object model API."

"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!"

"Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions. Configuration files describe to Terraform the components needed to run a single application or your entire datacenter. Terraform generates an execution plan describing what it will do to reach the desired state, and then executes it to build the described infrastructure. As the configuration changes, Terraform is able to determine what changed and create incremental execution plans which can be applied. The infrastructure Terraform can manage includes low-level components such as compute instances, storage, and networking, as well as high-level components such as DNS entries, SaaS features, etc."