1. A Crash Course on Celluloid

    12:41

    from Bascule / Added

    486 Plays / / 0 Comments

    Celluloid is a concurrent object library for Ruby inspired by the Actor Model. This screencast provides a quick overview of Celluloid's features and how you might use them in a web application.

    + More details
    • An Extempore Technical Introduction

      34:57

      from Andrew Sorensen / Added

      1,190 Plays / / 3 Comments

      This is not a "performance" or a general introduction. Instead it is a somewhat congested, and probably confusing, introduction to some of the more technical aspects of Extempore. In particular concurrency, the compiler, audio signal processing, and runtime binding to dynamic libraries. It's almost certainly premature to be making screencasts with Extempore, however, I've thrown this together because, as they say, a screencast is worth a thousand words. The audio is slightly out of sink but this shouldn't cause to much trouble for this introductory video. In this screencast Extempore is running in Emacs under Ubuntu Linux. Extempore: https://github.com/digego/extempore http://groups.google.com/group/extemporelang

      + More details
      • Actors: can we do better?

        29:20

        from Nathan Hamblen / Added

        850 Plays / / 0 Comments

        Paul Chiusano presents to the Northeast Scala Symposium http://nescala.org/

        + More details
        • Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors

          57:41

          from Nathan Hamblen / Added

          1,543 Plays / / 0 Comments

          Jonas Bonér presents to the Northeast Scala Symposium http://nescala.org/

          + More details
          • Exploring alternative Concurrency Paradigms on the JVM

            01:07:23

            from JAX TV / Added

            541 Plays / / 0 Comments

            Writing concurrent programs in Java is hard and writing correct concurrent programs is even harder. What should be noted is that the main problem is not concurrency itself but the use of mutable shared state. Reasoning about concurrent updates to, and guarding of, mutable shared state is extremely difficult. It imposes problems like dealing with race conditions, deadlocks, live locks, thread starvation etc. It might come as a surprise to some people but there are alternatives to the so-called "Shared-State Concurrency" (that has been adopted by C, C++, Java and has become the default industry standard way of dealing with concurrency problems). In this talk Jonas Bonér will discuss the importance of immutability and explore alternative paradigms such as Dataflow Concurrency, Message-Passing Concurrency and Software Transactional Memory (STM).

            + More details
            • Ulf Wiger

              01:05:33

              from The Bitsource / Added

              396 Plays / / 2 Comments

              + More details
              • Arrrrcamp 2010.10: Concurrency: Rubies, Plural by Elise Huard

                34:44

                from Openminds / Added

                78 Plays / / 0 Comments

                For the last few years hardware manufacturers have driven increasingly powerful multi-core processors into consumer-grade computing hardware. Power which twenty years ago was restricted to a handful of government-funded research institutes is now available on the desktop, introducing many developers to the conundrum of how best to use it with languages implemented primarily for sequential environments. In this presentation we'll use code to explore the various traditional models for concurrent execution supported directly by Ruby - such as Threads, Processes and Fibres - and their limitations before turning to the approaches pioneered in other languages and seeing how many we can bring into the Ruby fold. We'll present characteristic examples of techniques drawn from a variety of languagesand demonstrate how to construct similar architectures in Ruby using its native features and libraries such as EventMachine or RevActor.

                + More details
                • Performance Tuning on Go 2.0

                  42:31

                  from Yogi Kulkarni / Added

                  121 Plays / / 0 Comments

                  Go 2.0 (http://www.thoughtworks-studios.com/go) included a bunch of architectural changes including introduction of a JRuby on Rails frontend (instead of Spring MVC) and Hibernate in the backend (which now co-exists with iBatis). As part of the release we spent a lot of time time on identifying and fixing performance bottlenecks. This talk will cover how we approached this and the lessons learned, including... * JRuby gotchas and why running Jruby on Rails in multi-threaded mode is pretty much uncharted territory. * Rails view rendering bottlenecks, or "why do 10 concurrent requests take 90 seconds to complete"! * Why cache invalidation really is one of the 2 hard problems in Computer Science, and how to deal with it. * The right way to do view fragment caching. * Why you have to worry about thread-safety AND transactions. * Using a profiler to identify bottlenecks and lock-contention, and how to reduce lock granularity. * Why database size is critical for performance tuning. SQL tuning tips and gotchas.

                  + More details
                  • Anatomy of Message Passing, part 2

                    49:48

                    from Bartosz Milewski / Added

                    321 Plays / / 0 Comments

                    In the second part of the presentation I discuss the goals and the implementation of a C++ message-passing library which is based on Events and Channels. What makes it stand apart from other such libraries is its expressive power, lack of restrictions on message types and their storage, and composability.

                    + More details
                    • Anatomy of Message Passing, part 1

                      52:27

                      from Bartosz Milewski / Added

                      943 Plays / / 0 Comments

                      A presentation given by Bartosz Milewski at the Northwest C++ Users Group, May 19, 2010. This is part 1, in which I discuss various message passing models, in particular Caml's channels and events. Also a short intro to C++0x synchronization primitives: mutex, lock_guar, and condition_variable.

                      + More details

                      What are Tags?

                      Tags

                      Tags are keywords that describe videos. For example, a video of your Hawaiian vacation might be tagged with "Hawaii," "beach," "surfing," and "sunburn."