For that matter, it's an incredibly anachronistic and inaccurate usage of systems programming. People generally reserve systems programming to problems that in order to be solved require something closer to gluing toothpicks than spraying memory.
On topic then, this is the first time I see Scala syntax and was somewhat pleasantly surprised (the only languages I really know are JavaScript and Python).
case class Stock(ticker: String, price: Double) {
def <(other: Stock) = price < other.price
}
val goog = Stock("GOOG", 675.15)
val aapl = Stock("AAPL", 604.00)
aapl < goog == true
goog < aapl == false
Correct me if I'm wrong but it seems to me that the class Stock gets a method called "<". So appl.< google (or the other way around) would also work. The previous slide also shows this, but the Stock example is makes it even clearer that "Scala is a pure object oriented language: every value is an object." appl and goog are objects, of type Stock, and < is an object, a method of Stock.
I wonder if this kind of method would work
def ==(other: Stock) = price != other.price
and what would happen if it was like this
def ==(other: Stock) = self != other
(where self would be a reference to the Stock instance, ala python, or this in javascript)
Isn't this ability a bit dangerous or worrisome? It means that for every Scala package you use you need to review the code. It does make a good prank though :)
There is a library called Dispatch that has/had this problem entirely, the author decided to use symbols instead of natural language method names and left it fairly undocumented, so you had to spend time reading the source to have any idea what was going on. To the point where a kindly soul decided to write a periodic table (http://www.flotsam.nl/dispatch-periodic-table.html) to help people with its use.
I wouldn't say it was particularly dangerous, but it is a massive pain to deal with (it also means you can google for any help with a particular method).
For what it's worth, this is how Ruby operates, as well - "a + b" is really "a.+(b)". In practice, it doesn't end up being very dangerous. Maybe it's just a community thing (the potential for abuse is certainly there), but it means that you get some really nice, natural-feeling code when you do need to use those overrides.
Off-topic somewhat, but I appreciate the way the slides used `location.replace('#'+n)` so my browser history wasn't littered with slide navigations, hence the back button brought me back here (but slides are still bookmarkable).
Scala is interesting but as others have pointed out, I think it gives a disservice to the presentation to call it "Systems programming at Twitter" .
To me it shows two things:
* The author doesn't know what system programming is;
* Future, promises and generally speaking asynchronous operations are I/O management 101. It doesn't paint your company in a good light to exhibit these techniques as "how we do things".
Hello from the author. Indeed the vernacular has changed, and “systems programming” refers also to the distributed systems server software.
Composable futures and promises are still fairly new in use; I would wager our systems are some of the largest using the techniques described therein.
While this talk focused on composable IO and services, there is much more to it. Finagle (https://github.com/twitter/finagle) is where the rubber meets the road. Its interfaces are described in these terms and it makes great use of their power.
Also, as with any talk, it is difficult to convey the message using only the slides.
Generally speaking futures and promises are new labeled "as is" but asynchronous I/O really isn't and is actually a requirement if you want to write something efficient.
I understand that slides convey a small percentage of information and I really hope I didn't come up as snarky.
That being said, when you say "I would wager our systems are some of the largest using the techniques described therein" I think you should visit a stock exchange. ;)
As for us, we've stopped using futures and promises for asynchronous operations as we've found faster way to manage operations (our system is written in C++11).
The best is to design your system in a way that you never have to wait/synchronize at all.
> As for us, we've stopped using futures and promises for asynchronous
> operations as we've found faster way to manage operations (our system
> is written in C++11). The best is to design your system in a way that
> you never have to wait/synchronize at all.
I think you've perhaps misunderstood: the futures described in the
presentation are not at all like, say for instance std::future or
java.util.concurrent.Future - that's why I called them "composable
futures". `flatMap` is the key to great power.
Our systems, using this variant of a "future", do not wait or
synchronize at all, as you describe.
Another thing that I highlight a lot in the presentation itself, but
does not come through in the slides is that this doesn't really have
anything to do with asynchronous IO at all, it has to do with
composing your operations from smaller operations. It's possible to
use asynchronous IO (as we do—with asynchronous operations throughout,
and with no waiting), but that is not necessary. The important bit is
this: composing larger operations from smaller ones leads to
inherently modular code; code that composes well within the context of
larger systems. That's the important bit. That it is also easy to
implement a performant execution system for this is gravy.
>The author doesn't know what system programming is
No, it's that systems programming is not what it was. The term now also applies to large scale server side systems, not just drivers and lower level work. See also how Go was presented as a "systems language" for these same uses.
>Future, promises and generally speaking asynchronous operations are I/O management 101. It doesn't paint your company in a good light to exhibit these techniques as "how we do things".
I/O 101? You'd be surprised. Take a look around the industry, and even HN posts, and you'll find out this is far far from the truth.
I couldn't agree more, if this is I/O 101 then most network programmers I've met weren't even aware this course existed!
Heck, back when I was in CS I had one teacher who was saying "use Java applets for web forms, its more secure since you can't right click to view the source to see the field names in order to forge a request". Somehow most of his students ended up on government contracts..
If you take slides 52[1] to 63[2], you can see the emphasis put into run-time diagnosis.
Which is really important for largely distributed systems. Google wrote a little about it when they introduced their global run-time performance tracing tool called Dapper[3] in "Dapper, a Large-Scale Distributed Systems Tracing Infrastructure"[4]"
Modern Internet services are often implemented as complex, large-scale distributed systems. These applications are constructed from collections of software modules that may be developed by different teams, perhaps in different programming languages, and could span many thousands of machines across multiple physical facili- ties. Tools that aid in understanding system behavior and reasoning about performance issues are invaluable in such an environment.
I agree this is more about scala than system programming..
I was very happy back then when scala shows up..
but with time i think computer languages should just get out of your way.. be simple as possible..
nowadays im more a Dennis Ritchie/Ken Thompson fan..
they had make simple tools with C and Unix, that just worked..
This is also the Go language school of thought..
Languages must get out of our way, get things done in the simplest way possible..
Functional language people , are more passionate about proving some theoretical points
like using immutability all way down.. even if this will blow out your memory resources, or make your code longer..
i think language designers need to be more pratical, and i like when the simplicity way of thought like the one seen in Go comes around the table, to make discussion a little bit more interesting..
We nee more simplicity, work less, so we can be more with our children or family.. and spending less time on our computer.
It is possible that you're making the same mistake you accuse the author of making. "You have a hammer and are seeing everything as a nail, but I have a screwdriver and all those things are actually screws."
