Category Archives: JVM

Scala: Links, News And Resources (6)

Previous Post

Concurrent and Distributed Applications with Akka, Java and Scala
by @frodriguez

A better Java: Scala or Xtend?

Ken Little on Scaling Tumblr

Scala 2013: A Pragmatic Guide to Scala Adoption in Your Java Organization

Java NIO and Scala Continuations
Combining Java’s NIO non-blocking input/output with Scala’s delimited continuations allows making a multi-client stateful server that does not require a a dedicated thread for every active client.

ReactiveMongo for Scala: Unleashing MongoDB Streaming capabilities for Realtime Web

Effective Scala

Rúnar Bjarnason on Scalaz, Lenses, Functional Programming and Scala

Scala Adding Macros to the Language

janm399 / akka-patterns
Demonstration of the common Akka patterns

Java 8 vs Scala: a Feature Comparison

Why Scala? Our Take at Boundless

Scala, Functional Programming and Play 2.0
Sadek Drobi discusses functional programming sand Scala’s multi paradigm approach at QCon London 2012. He also shares insights into the new Play 2.0 framework.

Scala ou Java? Explorando mitos, polêmicas e fatos

A Startup Junkie’s Journey to Python via Java, Ruby and Scala

Programming Language Performance

Compile Online

Ozma: Extending Scala with Oz Concurrency

Workshop: Build an Image Processing Server

romix / akka-protostuff-serialization
protostuff-runtime based serializers for Akka

romix / akka-quickser-serialization
quickser based serializers for Akka

Play!: I’ll See Your Async and Raise You Reactive
Guillaume Bort and Sadek Drobi introduce Play, a Java and Scala web development framework, insisting on its asynchronous reactive capabilities built on Iteratee IO.

Building Polyglot Systems with Scalang
Cliff Moon discusses Scalang, a message passing and actor library enabling easy communication between Scala and Erlang apps, wrapping services in Scalang actors.

Learn Scala with a Programming Game

The Scala Compiler Corner
A collection of resources for compiler hackers

tim8dev / play-akka-pi
Pi Approximation distributed over the network using AKKA 2.0 Remote Actors 🙂

debasishg / cqrs-akka
An implementation of CQRS using scalaz for functional domain models and Akka for event sourcing

My Links

Keep tuned!

Angel "Java" Lopez

Scala: Links, News And Resources (5)

Previous Post
Next Post

CQRS with Akka actors and functional domain models

Akka Consumer Actors: New Features and Best Practices

MongoDB for Akka Persistence

PubSub with Redis and Akka Actors

Above the Clouds: Introducing Akka

Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors

Starting with Akka and Scala

Akka and the Java Memory Model

Task Dispatch and Nonblocking IO in Scala

spray / spray
spray is a suite of lightweight Scala libraries for building and consuming RESTful web services on top of Akka.

Benchmarking JVM Concurrency Options for Java, Scala and Akka

Functional Java
…Fully operational Actors for parallel computations…

Cassie: A Scala client for Cassandra

Scalding, a Scala API for Cascading

Esos raros lenguajes nuevos NodeJs, Scala, Clojure, Erlang, Python, Ruby

Combinator Parsing

(take 5 daniel-spiewak)
Daniel Spiewak is a highly respected member of the Scala programming language community and an overall thoughtful polyglot

Nick Kallen Discusses Scala at Twitter

The Why and How of Scala at Twitter

Lang.NEXT Trip Report

Pervasive Parallelism in Scala

twitter / util
Wonderful reusable code from Twitter

Learn about Efficient Functional IO in Scala from John De Goes’ Presentation at NEScala

Thinking Scala
Scala is one of those languages that’s almost too smart for it’s own good. I like everything about it, but I still think it lacks appeal to a wide audience.

Actor Applications
This website serves as a collection of Akka/Scala actor applications.

Actor References, Paths and Addresses

Differences between pattern matching and unification?

Supervision and Monitoring

SIP-18 – Modularizing Language Features

My Links

Keep tuned!

Angel “Java” Lopez

Scala: Links, News And Resources (4)

Previous Post
Next Post

Word Count MapReduce with Akka

All #Actors in #Scala – compared

London Scala days 2012

Iteratees Page History

Introducing Typesafe Stack 2.0

Diagrams of the Fault Tolerance Sample (Scala)

Why functional programming matters (aka MapReduce for humans)

Concurrency in Erlang & Scala: The Actor Model

What is actor model in context of a programming language?

The Big Three – Scala, Clojure and Groovy

Akka Project

Scala > Java

A Non-Blocking Factorial Function? (Programming with Actors and Continuations)!topic/scala-user/QD73Ijckjpg

A DSL for Continuation Passing Style in Scala

NorthEast Scala

Real life Scala feedback from Yammer

Scala, Akka, and Play: An Introduction on Heroku

The Middleware Connection: Scala, Akka, and Heroku

Scaling Out with Scala and Akka on Heroku

Talking about Akka, Scala and life with Jonas Bonér

Scala, Akka, and Play!: An Introduction in the Cloud

Heroku supports Play!, Akka and Scala

Scala & Akka Creators Launch Typesafe Company for Multicore and Cloud Architectures

Akka Future vs. Twitter’s Finagle Future!msg/akka-user/eXiBV5V7ZzE/3VrLg855SrAJ

My Links

Keep tuned!

Angel “Java” Lopez

Scala: Links, News And Resources (3)

Previous Post
Next Post

Scalaz: Type Classes and Pure Functional Data Structures for Scala

Suppose you had to choose between Clojure and Scala, which would you pick?

ScalaIDE for Eclipse

Scala for the Intrigued: Creating Higher Order Functions

Scala for the Intrigued: Working with Collections
n this fifth installment of his series on the Scala programming language, Venkat mixes object oriented and functional styles to reveal the power and grace of Scala collections.

Scala for the Intrigued: Cute Classes and Pure OO
This third installment of his series on Scala shows how Scala’s OO purity leads to simple, elegant code.

Scala for the Intrigued: Functional Style of Programming
Venkat delves into the functional style of programming in Scala.

Languages, Verbosity, and Java
With the new spate of programming languages emerging for the Java virtual machine and other platforms, it’s more important than ever that the rules of a language make code clear and concise. But clarity and conciseness don’t exactly go hand in hand.

Running Spring Java and Scala Apps on Heroku

A little scalaz IO action

Functional IO in Scala with Scalaz

Everything I Ever Learned about JVM Performance Tuning @twitter
Attila Szegedi discusses performance problems encountered at Twitter running Java and Scala applications, presenting how they solve them through JVM tuning.

Offbeat: Scala by the end of 2011 – No Drama but Frustration is Growing

Real life Scala feedback from Yammer

Actors: can we do better?
Paul Chiusano presents to the Northeast Scala Symposium

scala symposium Boston

Continuations and Other Functional Patterns

Building an HTTP streaming API with Scala

Guerrilla Guide to Pure Functional Programming

Referentially transparent nondeterminism

Scala’s version fragility make the Enterprise argument near impossible
An attribute of Scala is that the Scala compiler generates fragile byte-code.  This means that all the code in an executable (JAR or WAR) must be compiled with the same library and compiler versions.

Functional Scala: Curried Functions and spicy Methods

Functional Programming For Java Programmer Scala Or Clojure?

Scala vs Ceylon vs Kotlin

Scala feels like EJB 2, and other thoughts

My Links

Keep tuned!

Angel “Java” Lopez

Scala: Links, News And Resources (2)

Previous Post
Next Post

More about Scala programming language and ecosystem

Learning Scala? Learn the Fundamentals First

Injectors and Extractors in Scala

How to maintain compatibility and language quality

Akka 2.x roadmap…

Look ma…. location transparency

London Scala Users’ Group:Practical Scalaz: making your life easier the hard way

jdegoes / blueeyes
A lightweight Web 3.0 framework for Scala, featuring a purely asynchronous architecture, extremely high-performance, massive scalability, high usability, and a functional, composable design.

Actors that Unify Threads and Events

Clojure vs Scala – anecdote Options

Contrasting Performance : Languages, styles and VMs – Java, Scala, Python, Erlang, Clojure, Ruby, Groovy, Javascript

Scala: Making it easier to abstract code

Scala: Companion Objects

Scala programming tutorial part 1. (environment setup)

Scala programming tutorial part 2. (executable, print)

Working Hard to Keep It Simple in Scala

Good article on Functional Programming #FunctionalProgramming #Scala #ErLang

Working Hard to Keep It Simple

My Links

More Scala resources are coming

Keep tuned!

Angel “Java” Lopez

Metaprogramming: Links, news and resources (1)

As a programming language fan and writer of many interpreters, I’m interested in metaprogramming. Some links I found useful:

Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime. In some cases, this allows programmers to minimize the number of lines of code to express a solution (hence reducing development time), or it gives programs greater flexibility to efficiently handle new situations without recompilation.

magarciaEPFL / MethodHandleUtils
JVM: Composing MethodHandles at runtime like AST nodes
Runtime metaprogramming via java.lang.invoke.MethodHandle

Ruby Metaprogramming: Declaratively Adding Methods to a Class

dlitvakb / MetaBuilder
A Ruby MetaProgramming Excercise

Adding Properties to Ruby Metaprogramatically

Ruby: More About Methods

Calling Methods Dynamically

Ruby dynamic method calling

celluloid / celluloid
Actor-based concurrent object framework for Ruby

MetaProgramming – Extending Ruby for Fun and Profit

Three implicit contexts in Ruby
Yehuda Katz wrote an article about self and metaclass. In the article he said that Person.instance_eval assigns Person’s metaclass to self for a class Person. But this is obviously wrong.
Ruby always has three implicit contexts: self), so called `klass’ and the constant definition point.

Metaprogramming in Ruby: It’s All About the Self

class << self idiom in Ruby


Default Ruby accessor method?
method_missing; it gets called whenever an undefined method is used

A Logic Meta-Programming Approach
to Support the Co-Evolution of
Object-Oriented Design and Implementation

Meta-level Programming with CodA

C#5 and Meta-Programming

Metaprogramming in .NET

Whole Platform
the Whole Platform provides an Eclipse-based Language Workbench for developing new languages, manipulating them using domain notations and transforming them using a generative model driven approach.

Code Generation on the JVM: Writing Code that Writes Code

Rascal – Meta Programming Language
Rascal is a domain specific language for source code analysis and manipulation a.k.a. meta-programming.

Write A Template Compiler For Erlang
Implementing the Django Template Language in Erlang

Groovy: Best Practices Developed From Distributed Polyglot Programming

The Magnificent Seven
creating a Lisp variant in seven forms

The calculator language tutorial

The art of metaprogramming, Part 1: Introduction to metaprogramming
One of the most under-used programming techniques is writing programs that generate programs or program parts. Learn why metaprogramming is necessary and look at some of the components of metaprogramming (textual macro languages, specialized code generators). See how to build a code generator and get a closer look at language-sensitive macro programming in Scheme.

Through the Looking Glass Darkly
The classic approach to reflection in object-oriented programming languages originates with Smalltalk, and is used in most class based languages that support reflection: define a reflective API on Objec
nother approach is used in many scripting languages. The language constructs themselves introduce code on the fly, modifying the program as they are executed.
The third approach is that of mirrors, and originates in Self. Mirrors have been used in class based systems such as Strongtalk, and even in the Java world. JDI, the Java Debugger Interface, is a mirror based reflective API. Here, the reflective operations are separated into distinct objects called mirrors.

Mirrors: Design Principles for Meta-level Facilities of Object-Oriented Programming Languages

Metaprogramming: Ruby vs. Javascript

Metaprogramming in Ruby

A Basic YAML Config Module For Ruby

Categories, the homemade object system


Why? Language Archaeology … and Metaprogramming

Metaclasses Demystified
The word “metaclass” often strikes fear into the hearts of Python programmers. This article explores metaclasses in an approachable way, in order to take the mystery out of metaclasses, and enable you to leverage metaprogramming techniques to solve real problems.

Dupping Our Way Out of Instance Eval

In this RubyFringe talk, Reginald Braithwaite shows how to write Ruby that reads, writes, and rewrites Ruby. The demos include extending the Ruby language with conditional expressions, new forms of evaluation such as call-by-name and call-by-need, and more.

Smalltalk magritte-metamodel
Magritte is a fully dynamic meta-description framework that helps to solve those problems, while keeping the full power to the programmer in all aspects.

My Links

More links about DLSs, programming languages, and metaprogramming are coming.

Keep tuned!

Angel “Java” Lopez