Tabela de Conteúdos
:: Topo :: doCoding :: Linguagens de Programação
Scala
- Scala (programming language) - Scala is a multi-paradigm programming language designed to integrate features of object-oriented programming and functional programming.
Learning
- Simply Scala - interactive online tuutorial.
Training Courses
Books
Resources
- Scala Language Search Engine - Blogs, Reference Documentation, Samples and Tutorials on the Scala Language.
Blogs & Wikis
-
- Graceless Failures - Learning Scala. The hard way.
-
Articles
- First Steps to Scala - In this article, you'll follow twelve steps that are designed to help you understand and gain some basic skills in the Scala programming language.
- Scala: A Scalable Language - In this article, which is based on Chapter 1 of the book, Programming in Scala, you'll get an overview of the Scala language and insights into its design.
- Twitter on Scala - Three Twitter developers, Steve Jenson, Alex Payne, and Robey Pointer, talk with Bill Venners about their use of Scala in production at Twitter.
- How Scala Changed My Programming Style - Learning a new programming language sometimes influences how you code in other languages, too. In this essay, Bill Venners shares how learning Scala influenced his programming style.
- The Origins of Scala - Martin Odersky talks with Bill Venners about the history that led to the creation of the Scala programming language.
- The Goals of Scala's Design - Martin Odersky talks with Frank Sommers and Bill Venners about the compromises and most important goals in Scala's design, its object-oriented innovations, and what's in it for you.
- The Purpose of Scala's Type System - Martin Odersky talks with Bill Venners and Frank Sommers about the design motivations behind Scala's type system.
- The Point of Pattern Matching in Scala - Martin Odersky talks with Bill Venners and Frank Sommers about the mechanics and purpose of pattern matching in Scala.
Java
- Scala for Java Refugees:
- The busy Java developer's guide to Scala:
- Phasing over from java to scala:
- The Seductions of Scala - Ignoring the functional programming aspects for a moment, I think Scala improves on Java in a number of very useful ways. So, even if you don’t believe in FP, you will gain a lot just by using Scala as a better Java. But, you shouldn’t ignore the benefits of FP! Of course, you can mimic some of these features in pure Java and I encourage you to do so if you aren’t using Scala.
- Part I - The most exciting OOP enhancement Scala brings is its support for Traits, a concept first described here and more recently discussed here. Traits support Mixins (and other design techniques) through composition rather than inheritance. You could think of traits as interfaces with implementations. They work a lot like Ruby modules.
- Part II - Functional Programming - It’s the immutable variables and side-effect free functions that help solve the multicore problem. Synchronized access to shared state is not required if there is no state to manage. This makes robust concurrent programs far easier to write. Value objects are beneficial because you can pass one around without worrying that someone will change it in a way that breaks other users of the object. Value objects aren’t unique to FP, of course. They have been promoted in Domain Driven Design (DDD), for example. Similarly, side-effect free functions are safer to use. There is less risk that a caller will change some state inappropriately. The caller doesn’t have to worry as much about calling a function. There are fewer surprises and everything of “consequence” that the function does is returned to the caller. It’s easier to keep to the Single Responsibility Principle when writing side-effect free functions.
- Part III - Concurrent Programming - Because pure functional languages have no side effects and no shared, mutable state, there is nothing to synchronize. This is the main reason for the resurgent interest in function programming recently, as a potential solution to the so-called multicore problem. Instead, most functional languages, in particular, Erlang and Scala, use the Actor model of concurrency, where autonomous “objects” run in separate processes or threads and they pass messages back and forth to communicate. The simplicity of the Actor model makes it far easier to create robust programs. Erlang processes are so lightweight that it is common for server-side applications to have thousands of communicating processes.
- Traits vs. Aspects in Scala - Scala traits provide a mixin composition mechanism that has been missing in Java. Roughly speaking, you can think of traits as analogous to Java interfaces, but with implementations. If you need to mix in behavior in a specific, relatively-localized set of classes, Scala traits are probably all you need and you don’t need another language. If you need more “pervasive” modifications (e.g., tracing, policy enforcement, security), consider using aspects.
Assorted
- [Scala] Introduction to Scala:
- Scala and XML - XML processing made easy
- Static typing and Scala - I’ve been looking at the Scala programming language recently. If you’re not familiar with it, Scala is a statically typed language with functional programming that runs on the Java Virtual Machine. Although I have always strongly favored statically typed languages, I have to admit that Scala might be one of the most persuasive arguments yet that the whole notion of static typing is fundamentally unsound.
- My verdict on the Scala language - The Scala language is intriguing, quite powerful, but tends toward being illegible when written “properly”. I’m not at all convinced that the average software developer is able to grasp Scala. At least, not beyond the basic abilities that could just as easily be expressed in Java. Heck, from what I can tell there are a lot of software developers who find Java to be beyond their full comprehension. Since I don’t have any confidence that the average software developer could understand Scala code that was written to actually take advantage of Scala, I can’t recommend it for application development.
- Are Scala' Case Classes a Failed Experiment? - From my understanding of Scala's history, case classes were added in an attempt to support pattern matching, but after thinking about the consequences of the points I just gave, it's hard for me to see case classes as anything but a failure. Not only do they fail to capture the powerful pattern matching mechanisms that Prolog and Haskell have made popular, but they are actually a step backward from an OO standpoint, something that I know Martin feels very strongly about and that is a full part of Scala's mission statement.
Actors
Monads
- Monads are Elephants:
Presentations
Tutorials
- Using Flex with Scala - Having to write less code to implement a given feature often improves developer productivity: less code means less bugs, less tests to write, and less artifacts to maintain. Just as recent advances in rich-client technologies reduce boilerplate code on the client, new languages targeting the Java Virtual Machine can yield similar benefits on the server. This article illustrates how Flex on the client, combined with Scala on the server, results in a highly effective client-server development model. The article also shows a way to use the Java Persistence API (JPA) from Scala code.
TDD
- Rehersal - Rehersal is a testing framework for Scala, intended as an easier-to-use replacement for SUnit in the standard library.
- ScalaCheck - ScalaCheck is a powerful tool for automatic unit testing of Scala and Java programs. It features automatic test case generation and minimization of failing test cases. ScalaCheck started out as a Scala port of the Haskell library QuickCheck, and has since evolved and been extended with features not found in Haskell QuickCheck.
- specs - specs provides a BDD framework for the Scala language.
Web Frameworks
- Lift - Lift is an expressive and elegant framework for writing web applications. Lift stresses the importance of security, maintainability, scalability and performance, while allowing for high levels of developer productivity.
- sweetscala - A Scala framework for building dynamic web applications.
- slinky2 - Slinky is a HTTP library for web applications using the Scala Programming Language.
Libraries and Toolkits
- vscaladoc - A variation of scaladoc : an API generator for project written in Scala.
Concurrency
- scala-otp - The Scala OTP project implements a platform and runtime for deployment, execution and management of Scala Actors, similar to Erlangs OTP platform, for implementation of highly fault-tolerant, distributed actor-based enterprise systems.
- clustered-fold - A Scala Actors based parallel-Fold that uses Terracotta for clustering.
- scala-stm - An implementation of a software transactional memory framework in Scala.
- smr - Scala Map Reduce
- scala-dataflow - Oz-style dataflow (single-assignment) variables and streams for Scala.
DataBase
- scala0.orm - An O/R mapping tool for scala.
- scorm - I'm writing an ORM in Scala as an exercise for the Bmore Hackers language study group.
- scalajpa - A framework for making JPA easier to use with Scala code.
- squery - Scala SQL Query DSL
- scala-query - A type-safe database query API for Scala
- scouchdb - Scala CouchDB client.
Collections
- scala-javautils - A set of utilities for dealing with Java and Scala collections.
- scala-collections - A number of collection implementations for Scala (including a few ported from Clojure).
- CompactHashMap - Fast and memory-compact (especially on primitive types) scala HashMap and HashSet.
Logging
Building
- sbt - simple-build-tool - A build tool for Scala.
- scala-build - Ant/Ivy build scripts to automate building scala projects.
- scala-buildr-base - A skeleton project structure for developing with scala, testing with specs and building with buildr.
