Recording Venue: Skype
Guest: Jonas Boner
This episode is a conversation with Jonas Boner about Akka. Akka is a Scala-based framework for concurent and distributed applications, providing among other things support for actors, remote communication, transactional memory. In the episode we take a look at the most important aspects of Akka, as well as how and where it is used today. We also briefly talk about Jonas’ involvment in the Typesafe company.
Podcast: Play in new window | Download
Recording Venue: Skype
Guest: Martin Odersky
Host: Markus
This episode is an update on the developments around the Scala language. We covered the new features in 2.7 and 2.8, as well as what’s planned for 2.9. We then discussed briefly the different “proficiency levels” of Scala programmers. The main part of the episode centered around Martin’s new research project: the polymorphic embedding of DSLs for expressing concurrency into Scala.
Links:
Podcast: Play in new window | Download
Recording Venue: OOP 2009
Guest(s): Bruce Sams
Host(s): Markus
The majority of hacker attacks (70 %) are directed at weaknesses that are the result of problems in the implementation and/or architecture of the application. This session shows how you can protect your web applications (J2EE or .NET) against these attacks. The session covers lots of practical examples and techniques for attack. Furthermore, it shows strategies for defense, including a “Secure Software Development Lifecycle”. A “Live Hacking” demo rounds it out.
This is a session recorded live at OOP 2009. SE Radio thanks Bruce, SIGS Datacom and the programme chair, Frances Paulisch, for their great support!
Links:
Podcast: Play in new window | Download
Recording Venue: JAOO 2007
Guest(s): Joe Armstrong
Host(s): Markus
In this Episode we’re talking about Erlang with its creator Joe Armstrong. We started by looking at the history of the Erlang language and why it is so relevant today.
We then looked at Joe’s approach to Concurrency Oriented Programming and its main ingredients: share nothing, lightweight concurrency and pure message passing. We also compared this to the classic shared memory approach to concurrency. We then looked at other interesting aspects of Erlang, such as its functional nature (and why this is important to concurrency) and pattern matching. Next we discussed how to implement distribution and fault tolerance, and we took a look at OTP, the “application server” for Erlang.
We concluded the conversation with a littel discussion about how Erlang was designed, it’s current community as well as its future.
Links:
Podcast: Play in new window | Download
Recording Venue: OOPSLA 2007
Guest(s): Dan Grossman
Host(s): Markus
This episode features a discussion with Dan Grossman about an essay paper he wrote for this year’s OOPSLA conference. The paper is about an analogy between garbage collection and transactional memory. In addition to seeing the beauty of the analogy, the discussion also serves as a good introduction to transactional memory (which was mentioned in the Goetz/Holmes episode) and – to some extent – to garbage collection.
Links:
Podcast: Play in new window | Download
Recording Venue: OOPSLA 2006
Guest(s): Brian Goetz
David Holmes
Host(s): Markus
This is another episode on concurrency. We talk to two experts in the field, Brian Goetz and David Holmes about aspects of concurrency we hadn’t really covered before.
We start out by discussing liveness and safety and then continue to talk about synchronizers (latches, barriers, semaphores) as well as the importance of agreeing on protocols when developing concurrent applications. We then talked about thread confinement as a way of building thread-safe programs, as well as using functional programming and immutable data. The next set of topics covers various ways of how compilers can optimize the performance wrt. to concurrency, talking about techniques such as escape analysis as well as lock elision and coarsening. We then covered how to test concurrent programs and the consequences of the Java memory model on concurrency. We then went on to look at some more advanced topics, namely, lock-free programming and atomic variables. We also briefly discussed the idea of transactional memory.
Finally, we looked at how better language support – specifically, a more declarative style of concurrent programming as e.g. in the Fortress language – can aid in improving the quality of concurrent programs.
Links:
Podcast: Play in new window | Download
Recording Venue: JAOO 2006
Guest(s): Guy L. Steele Jr.
Host(s): Markus
This episode is an interview with Guy L. Steele Jr.. Guy is a Sun Fellow and heads the Programming Language Research Group within Sun, and a generally well known “programming language guy” (see here for details). We briefly talk about Lisp and the resurgence of dynamic languages before we delve into the main topic, the Fortress programming language he is working on. Fortress is a language intended to replace Fortran as a scientific computing language. We talk about how mathematical notations, syntax extensio and built-in support for parallelism are crucial properties of such a language. We then briefly talk about potentials for compiler optimization before taking a closer look at the type system (static typing, type inference), traits and contract specification as well as first-class support for hierarchical components. We conclude the discussion with a look at automatic partitioning and distribuion of concurrent algorithms and a brief look at the future roadmap for the Fortress language.
Links:
Podcast: Play in new window | Download
Recording Venue:
Guest(s):
Host(s): Michael Alexander
Recording Venue:
Guest(s):
Host(s): Michael Alexander
The third part of our concurrency series by Michael and Alexander discusses how to build highly scalable servers. The discussion focusses especially on event-driven servers. As possible solution patterns a reactor-based design is suggested along-side several patterns for multi-threading issues: Reader/Writers Locks, Thread Pools, and Leader/Followers.
Links:
Podcast: Play in new window | Download
Recording Venue:
Guest(s):
Host(s): Michael Alexander
Recording Venue:
Guest(s):
Host(s): Michael Alexander
In this second part of our concurrency series Michael and Alexander talk about basic patterns for concurrent programming, such as Active and Monitor Object, Scoped Locking and Futures. Further, they discuss some architectural considerations regarding the number of threads and resource usage in general. For more information, see the references for part one as well as the following links
Links:
Podcast: Play in new window | Download
Recording Venue:
Guest(s):
Host(s): Alexander Michael
Recording Venue:
Guest(s):
Host(s): Alexander Michael
This is the first part of a series of Concurrency episodes. In this part Alex and Michael motivate and introduce the topic. We explain fundamental terms, such as thread, process, or mutex and dicuss typical challenges, such as deadlocks and race conditions.
Links:
Podcast: Play in new window | Download
IEEE Software magazine presents Software Experts Summit 2013, which will focus on Smart Data Science: Harnessing Data for Intelligent Decision Making. Scheduled for 17 July at the Microsoft Campus in Redmond, Washington, speakers include James Whittaker of Microsoft, Paul Zikopoulos of IBM, Wolfram Schulte of Microsoft Research, John Howie of Cloud Security Alliance, Ayse Bener of Ryerson University, and Forrest Shull of the Fraunhofer Center for Experimental Software Engineering. Visit www.computer.org/ses13.
IEEE Software offers pioneering ideas, expert analyses, and thoughtful insights for software professionals who need to keep up with rapid technology change. It's the authority on translating software theory into practice.
Proud sponsor of SE-Radio.