Group items tagged

Functional is a library for functional programming in JavaScript. It defines the standard higher-order functions such as map, reduce (aka foldl), and select (aka filter). It also defines functions such as curry, rcurry, and partial for partial function application; and compose, guard, and until for function-level programming. And all these functions accept strings, such as 'x -> x+1', 'x+1', or '+1' as synonyms for the more verbose function(x) {return x+1}.

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

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

"Rust is a curly-brace, block-structured expression language. It visually resembles the C language family, but differs significantly in syntactic and semantic details. Its design is oriented toward concerns of "programming in the large", that is, of creating and maintaining boundaries - both abstract and operational - that preserve large-system integrity, availability and concurrency. It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles."

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

"Cats is an experimental library intended to provide abstractions for functional programming in the Scala programming language. "

"Service Component Architecture (SCA) is a set of specifications which describe a model for building applications and systems using a Service-Oriented Architecture (SOA). SCA extends and complements prior approaches to implementing services, and SCA builds on open standards such as Web services. SCA is based on the idea that business function is provided as a series of services, which are assembled together to create solutions that serve a particular business need. These composite applications can contain both new services created specifically for the application and also business function from existing systems and applications, reused as part of the composition. SCA provides a model both for the composition of services and for the creation of service components, including the reuse of existing application function within SCA compositions. SCA aims to encompass a wide range of technologies for service components and for the access methods which are used to connect them. For components, this includes not only different programming languages, but also frameworks and environments commonly used with those languages. For access methods, SCA compositions allow for the use of various communication and service access technologies that are in common use, including, for example, Web services, messaging systems and Remote Procedure Call (RPC)."

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

Haskell: The Craft of Functional Programming (3rd Edition)

Tengo ediciones anteriores, pero la 3a no la conseguí. Si la tenés, la quiero!

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

"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

"Graph for Scala is intended to provide basic graph functionality that seamlessly fits into the Scala standard collections library. Like the other members of scala.collection, Graph for Scala is an in-memory container that exposes a user-friendly interface without sacrificing functionality or flexibility. Graph for Scala also has ready-to-go implementations of JSON-Import/Export and Dot-Export - more popular graph serialization formats are coming soon. In addition, other powerful tools such as graph databases emulation and distributed graph processing are due to be supported."

"Monocle is a Lens library, or more generally an Optics library. Optics are a set of purely functional abstractions to manipulate (get, set, modify) immutable objects. Optics compose between each other and particularly shine with nested objects."

"JSch is a pure Java implementation of SSH2. JSch allows you to connect to an sshd server and use port forwarding, X11 forwarding, file transfer, etc., and you can integrate its functionality into your own Java programs."

"Complete and usable DNS library. All widely used Resource Records are supported, including the DNSSEC types. It follows a lean and mean philosophy. If there is stuff you should know as a DNS programmer there isn't a convenience function for it. Server side and client side programming is supported, i.e. you can build servers and resolvers with it."

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).