jessenoller.com - Python Threads and the Global Interpreter Lock
http://jessenoller.com/2009/02/01/python-threads-and-the-global-interpreter-lock/

interesting interesting!

oach the problem with what is now the near ubiquitous solution to the concurrency “problem”: Threads, a

more on the python-thread shennanigans. Better than most, but like many, seems to ignore GUI programming. Did webdev eat *everything* else?

Long story short, Rails can now serve multiple requests in more than one ruby threads ( or native threads if you’re on JRuby ) parallelly. Charles Nutter has done a good job of explaining the details here. Should you give a flying fuck ? You totally should if : * You’re using JRuby * You’re bold enough to play around with bleeding edge Neverblock stuff * Your application has a lot of long running processes, which are not heavy on blocking IO ( this would be rare I imagine ) You totally should NOT if : * You’re using Event based mongrel, thin or any of the event based web server in production. Event based servers don’t use Threads, so it just doesn’t matter. * You CBA You may have heard a bunch of hype about how threads make everything 100x faster, this is far from the truth. Don’t believe everything the hype merchants want to sell you, test your application first and see if it helps.

Concurrence is a framework for creating massively concurrent network applications in Python.

Concurrence is a framework for creating massively concurrent network applications in Python. It takes a Lightweight-tasks-with-message-passing approach to concurrency. The goal of Concurrence is to provide an easier programming model for writing high performance network applications than existing solutions (Multi-threading, Twisted, asyncore etc).

Concurrence is a framework for creating massively concurrent network applications in Python. It takes a Lightweight-tasks-with-message-passing approach to concurrency.

Super duper thingy

Lectures

This is the thirteenth post in an article series about MIT’s lecture course “Introduction to Algorithms.” In this post I will review lectures twenty and twenty-one on parallel algorithms. These lectures cover the basics of multithreaded programming and multithreaded algorithms.

เหมือนจะน่าสนใจ เก็บไว้ก่อน

Axum is a language that builds upon the architecture of the Web and principles of isolation, actors, and message-passing to increase application safety, responsiveness, scalability, and developer productivity. Other advanced concepts we are exploring are data flow networks, asynchronous methods, and type annotations for taming side-effects.

Axum is a language that builds upon the architecture of the Web and principles of isolation, actors, and message-passing to increase application safety, responsiveness, scalability and developer productivity.\

this lectures uses Playstation3 in their course.

"A 'worker' is a script that will be loaded and executed in the background. Web Workers provide a way to do this seamlessly, for example: new Worker("worker.js") - available in Firefox, Safari and Chrome - "If you're doing any computation with JavaScript you should definitely opt to use Web Workers if they're available"

Computing with JavaScript Web Workers

"Normally in order to achieve any sort of computation using JavaScript you would need to break your jobs up into tiny chunks and split their execution apart using timers. This is both slow and unimpressive ..."

Software Transactional Memory

http://queue.acm.org/detail.cfm?id=1454466

simple nice comment formatting.

A very interesting presentation on the past, present and future of webdev. Python and Django oriented.

That is, PHP suffers from most of the same problems as CGI, but to a lesser extent.

Joe Gregorio suggested Protocol Buffers as a efficient to implement inter-operation for applications built with different languages. Look in the comments for "Common Lisp Users" and laugh out loud. It's really true. Man, we, those who program as a business, are really screwed big time with mass concurrency problems.

Why do you hope you're using Python in 2020? I've been a Ruby developer for the last 3 years, but I don't hope I'm still using Ruby in 10 years. I hope something has come along by then and swept away my expectations of what programming can be like and replaced it with something that feels wholly new, like has happened for me multiple times. I'd feel stagnant and dependent if I was using one primary language for 10 years.

Bit of crystal ball peering

What sucks, now, about web development? How will we fix it? Can we fix it with Python?

Observation: Co-routines are to state machines what recursion is to stacks When you have to traverse some sort of a nested data structure (say, a binary tree), one approach is to create a stack that remembers where in the tree you are. Another, much more elegant approach, is to write the function recursively. A recursive function employs the machine stack used to implicitly implement function calls - you get the benefits of the stack without paying the cost of reduced readability.

libdispatch

オプソ!

Grand Central Dispatch user space library

Grand Central Dispatch Open Source Library

The open-source libdispatch project consists of the user space implementation of the Grand Central Dispatch API as seen in Mac OS X version 10.6 Snow Leopard.

Here’s my basic “How to learn about parallel programming in Haskell” reading list.

A haskell reading material

framework for writing network applications using asynchronous I/O in Python

diesel is a framework for writing network applications using asynchronous I/O in Python. It uses Python's generators to provide a friendly syntax for coroutines and continuations. It performs well and handles high concurrency with ease.

diesel is a framework for writing network applications using asynchronous I/O in Python.

diesel is a framework for writing network applications using asynchronous I/O in Python. It uses Python's generators to provide a friendly syntax for coroutines and continuations. It performs well and handles high concurrency with ease.

Persistent Data Structures and Managed References

Rich Hickey

good overview of concurrent data structures, refs and STM in Clojure

Rich Hickey is my new favourite presenter. The bloke is awesome (well except for the mullet you can see in this video)! In this video he discusses time as it relates to variable state, briefly applying it to clojure. What makes it great is his practical focus and his use of a really simple example to get across the point.

Joe Armstrong and Simon Peyton Jones discuss Erlang and Haskell

Interesting video where Joe Armstrong and Simon Peyton Jones engage in some friendly banter about functional programming and Erlang vs Haskell.

Solving 11 Likely Problems In Your Multithreaded Code

MSDN Library 2008/11 - Joe Duffy

Server-side programs have long had to deal with a fundamentally concurrent programming model, and as multicore processors become more commonplace, client-side programs will have to as well. Along with the addition of concurrency comes the responsibility for ensuring safety. In other words, programs must continue to achieve the same level of robustness and reliability in the face of large amounts of logical concurrency and ever-changing degrees of physical hardware parallelism.

Poor SQL; even with DSLs being the new hotness, people forget that SQL is one of the original domain-specific languages. It's a little verbose, and you might be bored with it, but it's much better than writing low-level mapreduce code.

Hazelcast is a clustering and highly scalable data distribution platform for Java. Features: Distributed implementations of java.util.{Queue, Set, List, Map} Distributed implementation of java.util.concurrency.locks.Lock Distributed implementation of java.util.concurrent.ExecutorService Distributed MultiMap for one-to-many relationships Distributed Topic for publish/subscribe messaging Transaction support and J2EE container integration via JCA Socket level encryption support for secure clusters Synchronous (write-through) and asynchronous (write-behind) persistence Second level cache provider for Hibernate Monitoring and management of the cluster via JMX Dynamic HTTP session clustering Support for cluster info and membership events Dynamic discovery Dynamic scaling Dynamic partitioning with backups Dynamic fail-over

Hazelcast is a clustering and highly scalable data distribution platform for Java.

Hazelcast is a clustering and highly scalable data distribution platform for Java. Features: * Distributed implementations of java.util.{Queue, Set, List, Map} * Distributed implementation of java.util.concurrency.locks.Lock * Distributed implementation of java.util.concurrent.ExecutorService * Distributed MultiMap for one-to-many relationships * Distributed Topic for publish/subscribe messaging * Transaction support and J2EE container integration via JCA * Socket level encryption support for secure clusters * Synchronous (write-through) and asynchronous (write-behind) persistence * Second level cache provider for Hibernate * Monitoring and management of the cluster via JMX * Dynamic HTTP session clustering * Support for cluster info and membership events * Dynamic discovery * Dynamic scaling * Dynamic partitioning with backups * Dynamic fail-over Hazelcast is for you if you want to * share data/state among many s

data distribution platform

This also shows that for massively concurrent problems, such as lots of parallel comet connections, the GIL in Python is a non-issue as we handle the concurrent connections in a single thread. In this post i am going to look at a selection of asynchronous servers implemented in Python.

Nice article on 2pc

Faster than C, safer than Java, simpler than *sh

[[int\]

In the first half of his introduction to actor concurrency, Alex Miller discussed the limitations of shared-state concurrency and explained how the actor model is expressed in Erlang. While Erlang is a nonstarter for many shops, actor implementations do exist for languages that run on the JVM. Find out how actors work and see them implemented using Scala's standard library, Groovy's GParallelizer, and the Java libraries Kilim, ActorFoundry, Actors Guild, and Jetlang.

Comparison of the LISP and HASKELL (functional) languages

Interesting read on some programming languages I hadn't heard of until today, they are still very useful apparently

patterns for parallel programming

"These two seem like an interesting combination. Imagine the possibilities...kill your database, simple POJO applications, free distributed transactions, clustered JVMs with limitless memory...it would make your hair would grow back, you'd get women, and become filthy rich...well...maybe not, but at least you'd have more fun writing software." -- Paul Stadig

good explanation of Ruby's threads & stack implementation

6s

ruby 1.8 mri assembly threads

Java Platform (AKA, JVM) library/framework for distributed, fault-tolerant system through Actors. Scala and Java APIs. Found through Dean Wampler. Project tag line is "Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors"

Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors (Erlang con API Java e Scala)

Learn to scale your UNIX® Python applications to multiple cores by using the multiprocessing module which is built into Python 2.6. Multiprocessing mimics parts of the threading API in Python to give the developer a high level of control over flocks of processes, but also incorporates many additional features unique to processes.

In a previous article for IBM® developerWorks®, I demonstrated a simple and effective pattern for implementing threaded programming in Python. One downside of this approach, though, is that it won't always speed up your application, because the GIL (global interpreter lock) effectively limits threads to one core. If you need to use all of the cores on your machine, then typically you will need to fork processes, to increase speed. Dealing with a flock of processes can be a challenge, because if communication between processes is needed, it can often get complicated to coordinate all of the calls. Fortunately, as of version 2.6, Python includes a module called "multiprocessing" to help you deal with processes. The API of the processing module has some similarities to the way the threading API works, but there are also few differences to keep in mind. One of the main differences is that processes have subtle underlying behavior that a high-level API will never be able to completely abst

In this interview filmed during QCon London 2008, Joe Armstrong, designer of Erlang, speaks on various aspects of the Erlang language, presenting its roots, how it compares with other languages and why it has become popular these days due to its native ability to scale on multi core systems.

Joe Armstrong About Erlang

Joe Armstrong

great erlang talks

Interesting post about java and concurrency problems, with some nice comments too: http://bit.ly/dtzUL1 – Sergio Bossa (sbtourist) http://twitter.com/sbtourist/statuses/15701705927

270,000