Fixed wireless on my hp dv9000 laptop.
"sudo apt-get purge bcmwl-kernel-source broadcom-sta-common broadcom-sta-source
sudo apt-get install b43-fwcutter firmware-b43-installer
After it intalls disconnect your wired connection and restart your computer."

"LogWatcher adds a view to Eclipse that allows log files to be monitored for changes, similar to the Unix tail utility."

watch clojure files on disk and autoreload them on change, kinda like jrebel

"Incanter is a Clojure-based, R-like platform for statistical computing and graphics."

"A declarative DSL for reading and writing binary file formats

This library implements a small DSL that is used to describe binary serialization formats. It was written to support reading and writing SuperCollider synthesizer definition files for Project Overtone, but it can be used for many binary file formats, network packets, etc..."

atoms, futures, agents, and promises

"Add Clippy or his friends to any website for instant nostalgia. Our research shows that people love two things: failed Microsoft technologies and obscure Javascript libraries. Naturally, we decided to combine the two."

"Bradford Cross recommends creating custom libraries containing composable abstractions instead of monolithic frameworks, exemplifying with Flop, Store, Graph, and Newsfeeds, all written in Clojure."

reflections on a safe dialect of C people used on lisp machines. All pointers were pairs of arrays and indicies ("fat pointers".

"Johann Sebastian Bach's Goldberg Variations in Overtone by @ctford."

"Don’t use scatterplots. Use a density plot such as a hexbin instead."

"I’ve just come back from EuroClojure 2012, where there were a number of Overtone talks and a number of tweets asking for music theory resources aimed at computer scientists. This will hopefully blog number 1 in a series on that theme."

"I think one of the main benefits of formal methods is to force you to say what you mean by "right". Proving is secondary."

"Clojure's data structures modified for use outside of Clojure"

"We must strive to understand that accidents don’t happen because people gamble and lose.
Accidents happen because the person believes that:
…what is about to happen is not possible,
…or what is about to happen has no connection to what they are doing,
…or that the possibility of getting the intended outcome is well worth whatever risk there is."

by using heaps

"Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.

Our goal is to change that. In these two books, the authors of four dozen open source applications explain how their software is structured, and why. What are each program's major components? How do they interact? And what did their builders learn during their development? In answering these questions, the contributors to these books provide unique insights into how they think."

a better repl, kinda like IPython

"A logging facility in Clojure is provided by the clojure.tools.logging module. This searches the JVM classpath for one of the various logging frameworks to delegate logging statements to.

While this is very useful, logging in Java has always been complicated to configure correctly. Fortunately, the two major logging 'back-ends' in Java (log4j and 'java.util.logging') support programmatic configuration so it is easy to replace the configuration file mechanisms with something that is easier and more flexible for Clojure programmers.

This library supports easy configuration via Clojure rather than Java properties files and XML. It is the author's belief that these confusing configuration formats reflect the static nature of the Java language itself and that Clojure should not inherit such complexity."

"There are, roughly speaking, three ways to develop large user-facing programs, which we will refer to here as 0) the Unix way, 1) the Emacs way, and 2) the wrong way."

rules for coming up with sane version numbers

"I covered topics an Apache Maven intro and its use for Android development with the Android Maven Plugin teaching Maven fundamentals and a whole bunch of things as they apply to Android and beyond. Sprinkled with lots of demos and samples we moved to understanding repository managers and used Sonatype Nexus for a few Android use cases. As a last step we use Eclipse Hudson to set up and run some continuous integration builds."

load up with context, then sleep on it

"So what exactly is git-playback? It's a bash script that goes through all commits in the current branch of repository and creates a slideshow using the specified files. "

"Most developers are morons, and the rest are assholes. I have at various times counted myself in both groups, so I can say this with the utmost confidence.

Assholes

Assholes read specs with a fine-toothed comb, looking for loopholes, oversights, or simple typos. Then they write code that is meticulously spec-compliant, but useless. If someone yells at them for writing useless software, they smugly point to the sentence in the spec that clearly spells out how their horribly broken software is technically correct, and then they crow about it on their blogs.

There is a faction of assholes that write test cases. These people are good to have around while writing a spec, because they can occasionally be managed into channeling their infinite time and energy into finding loopholes before the spec is final. Unfortunately, managing assholes is even harder and more time-consuming than it sounds. This is why writing good specs takes so long: most of the time is frittered away on asshole management.

Morons

Morons, on the other hand, don’t read specs until someone yells at them. Instead, they take a few examples that they find “in the wild” and write code that seems to work based on their limited sample. Soon after they ship, they inevitably get yelled at because their product is nowhere near conforming to the part of the spec that someone else happens to be using. Someone points them to the sentence in the spec that clearly spells out how horribly broken their software is, and they fix it.

Besides the run-of-the-mill morons, there are two factions of morons that are worth special mention. The first work from examples, and ship code, and get yelled at, just like all the other morons. But then when they finally bother to read the spec, they magically turn into assholes and argue that the spec is ambiguous, or misleading in some way, or ignoreable because nobody else implements it, or simply wrong. These people are called sociopaths. They will never write conformant code regardless of how good the spec is, so they can safely be ignored.

The second faction of morons work from examples, ship code, and get yelled at. But when they get around to reading the spec, they magically turn into advocates and write up tutorials on what they learned from their mistakes. These people are called experts. Virtually every useful tutorial in the world was written by a moron-turned-expert.

Angels

Some people would argue that not all developers are morons or assholes, but they are mistaken. For example, some people posit the existence of what I will call the “angel” developer. “Angels” read specs closely, write code, and then thoroughly test it against the accompanying test suite before shipping their product. Angels do not actually exist, but they are a useful fiction to make spec writers to feel better about themselves.

Why specs matter

If your spec isn’t good enough, morons have no chance of ever getting things right. For everyone who complains that their software is broken, there will be two assholes who claim that it’s not. The spec, whose primary purpose is to arbitrate disputes between morons and assholes, will fail to resolve anything, and the arguments will smolder for years.

If your spec is good enough, morons have a fighting chance of getting things right the second time around, without being besieged by assholes. Meanwhile, the assholes who have nothing better to do than look for loopholes won’t find any, and they’ll eventually get bored and wander off in search of someone else to harass."

"*JS is a typed dialect of JavaScript that offers a C-like type system with manual memory management. It compiles to JavaScript and lets you write memory-efficient and GC pause-free code less painfully, in short, *JS is the bastard child of JavaScript and C. *JS is early research prototype work, so don't expect anything rock solid just yet. The research goal here is to explore low-level statically typed features in a high-level dynamically typed language. Think of it as inline assembly in C, or the unsafe keyword in C#. It's not pretty, but it gets the job done."

he livecodes a noir app and cljs client which controls overtone

"The Google Libraries API is a content distribution network for the most popular, open-source JavaScript libraries. To add a library to your site, simply use <script> tags to include the library, as explained below."

;; This is an annotated example of the options that may be set in a
;; project.clj file. It is a fairly contrived example in order to
;; cover all options exhaustively; it shouldn't be considered a
;; representative configuration.

nonprofit open web index you can crunch with your own hadoop on EC2 instances

"Pallet is platform for agile and programmatic automation of infrastructure in the cloud, on server racks or directly on virtual machines. Pallet provides cloud provider and operating system independence, and allows for an unprecedented level of customization."

like JSFiddle

data explorer thing for Stack Exchange data

very simple and straightforward explanation

"Mocha is a feature-rich JavaScript test framework running on node and the browser, making asynchronous testing simple and fun. Mocha tests run serially, allowing for flexible and accurate reporting, while mapping uncaught exceptions to the correct test cases. "

"The Fat Jar Eclipse Plug-In is a Deployment-Tool which deploys an Eclipse java-project into one executable jar."

Apparently works for Clojure as well.

"In computing, the Two Generals' Problem is a thought experiment meant to illustrate the pitfalls and design challenges of attempting to coordinate an action by communicating over an unreliable link. It is related to the more general Byzantine Generals' Problem (though published long before that later generalization) and appears often in introductory classes about computer networking (particularly with regard to the Transmission Control Protocol), though it can also apply to other types of communication. It is also an important concept in epistemic logic, and the importance of common knowledge. Some authors refer to this as the Two Armies Problem or the Coordinated Attack Problem."

"This method – originally posted on Github by John Long, though probably not originally discovered by him – uses native parsing abilities built into the DOM to give you simple access to the parts of a URL simply by querying properties of an anchor element. Check it out:"

"Backup and restore your gmail account at will.

Liberate your emails and never lose that part of your life."

"What’s better than programming a GPU with a high-level, Haskell-embedded DSL (domain-specific-language)? Well, perhaps writing portable CPU/GPU programs that utilize both pieces of silicon—with dynamic load-balancing between them—would fit the bill.

This is one of the heterogeneous programming scenarios supported by our new meta-par packages. A draft paper can be found here, which explains the mechanism for building parallel schedulers out of "mix-in" components. In this post, however, we will skip over that and take a look at CPU/GPU programming specifically."

"Solarized terminal theme for KDE 4's Konsole terminal client. This was adapted from the Xresources file from March 31, 2011 and so contains the same color designations present there."

"Apache Shiro is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the smallest mobile applications to the largest web and enterprise applications."

Chas Emerick's excellent video introduction to clojure and the counterclockwise eclipse plugin

"OpenShift is Red Hat's free, auto-scaling Platform as a Service (PaaS) for applications. As an application platform in the cloud, OpenShift manages the stack so you can focus on your code."

"Adding lorem ipsum text to HTML documents involves copy-pasting, manual editing, and increasingly unwieldy code.
By interpreting your semantic HTML5 tags, Fixie will automagically add the right type of content in the right places. Headings, paragraphs, links, images, sections... trust me, it's all there. That way you can focus on your design, instead of finding the right filler content."

"Language Immersion for Chrome is an experimental extension that aims to simulate the experience of being immersed in a foreign language. By switching certain words and phrases from English into a language of your choice, the websites you already visit can provide a way to experience the world from a different perspective."

"The open-source /url/#{rewriting} solution for Servlet, JSF, and Java EE"

"PrettyFaces is an OpenSource Filter-based Servlets extension with enhanced support for JavaServer Faces – JSF 1.1, 1.2 and 2.0 – enabling creation of bookmark-able, pretty URLs. PrettyFaces solves the “RESTful URL” problem elegantly, including features such as: page-load actions, seamless integration with faces navigation, dynamic view-id assignment, managed parameter parsing, and configuration-free compatibility with other web frameworks."

""""
Querydsl is a framework which enables the construction of type-safe SQL-like queries for multiple backends including JPA, JDO and SQL in Java.

Instead of writing queries as inline strings or externalizing them into XML files they are constructed via a fluent API.

- Code completion in IDE (all properties, methods and operations can be expanded in your favorite Java IDE)
- Almost no syntactically invalid queries allowed (type-safe on all levels)
- Domain types and properties can be referenced safely (no Strings involved!)
- Adopts better to refactoring changes in domain types
- Incremental query definition is easier
"""

some kiwi NZ guys talking about java and such

favorites:
"Yoda conditions"
"Stringly Typed"
"Higgs-Bugson" (unreproducable)
"Baklava Code" (too many layers)
"Common Law Feature"

"This extension resizes the browser's window in order to emulate various resolutions. It is particularly useful for web designers and developers by helping them test their layouts on different browser resolutions.
"

wikibook about JPA and such

*very* embedded glassfish

guy uses haskell to recover jpegs from a corrupt disk

several cloud providers were leaking secrets in unallocated disk space

windows should be more like linux, and always do 8-bit strings, and consider them utf8.

fast C++ <---> JVM interop via C++ continuations and closures/lambdas

"This is a distribution of plug-ins and mappings for Vim, Gvim and MacVim.

It is designed to provide minimal working environment using the most popular plug-ins and the most common mappings."

podcast offering "weekly discussion about topics relating to the Java/JVM space with an Auckland and New Zealand focus."

"Virtualized development made easy.
Create and configure lightweight, reproducible, and portable development environments."

"Try JSIL out in your browser! Type some C# into the Source Code box below, and click Compile & Run.
The C# you enter is compiled on the JSIL server using the Mono compiler, then translated to JavaScript by JSIL and sent back to you."

"Never use JSF managed beans unless you are working in a servlet container and don’t want to try and get CDI working in Tomcat (although I have a Maven archetype for that so there’s no excuse).

In general, you should use CDI beans unless you need the advanced functionality available in the EJBs such as transactional functions. You can write your own interceptor to make CDI beans transactional, but for now, its simpler to use an EJB until CDI gets transactional CDI beans which is just around the corner. If you are stuck in a servlet container and are using CDI, then either hand written transactions or your own transaction interceptor is the only option without EJBs."

"Clojure with a type system, as a library."
looks a bit haskelly

javascript DSL for synthesizing DOM elements. probably slower than html though.

"And thus Chrome used WebKit, and pretended to be Safari, and WebKit pretended to be KHTML, and KHTML pretended to be Gecko, and all browsers pretended to be Mozilla, and Chrome called itself Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13, and the user agent string was a complete mess, and near useless, and everyone pretended to be everyone else, and confusion abounded."

a series of scripts that use google & torrent search rss feeds to find database dumps

"necessary-evil is an implementation of XML-RPC built on top of the ring http library for Clojure. XML-RPC is a bit nasty, but it is the basis of a number of other standards such as certain blogging APIs and Ping Back."

to prevent an eclipse bug which removes needed static imports
"Change 'Number of static imports needed for .* to '1'"

"I think that I shall never envision
An op unlovely as division.

An op whose answer must be guessed
And then, through multiply, assessed;

An op for which we dearly pay,
In cycles wasted every day.

Division code is often hairy;
Long division's downright scary.

The proofs can overtax your brain,
The ceiling and floor may drive you insane.

Good code to divide takes a Knuthian hero,
But even God can't divide by zero!"

TomEE: Apache Tomcat with EE example projects

lots of tutorials for Java Server Faces

"Fast, Isolated, Repeatable, Self-Verifying, and Timely"

"Midje is a test framework for Clojure. I created it to support top-down as well as bottom-up testing, to encourage readable tests, to provide a smooth migration path from clojure.test, to support a balance between abstraction and concreteness, and to be gracious in its treatment of you, my valued guest."

"how to go about bundling JAX-RS services in a jar and then using them from a war."

"LCPU is a simple Lisp-like language that compiles to optimized DCPU-16 assembly code. It is a very restricted subset of Lisp. There is no GC, and thus no data structures or run-time closures."

log verbosely but contingently into something cheap like a hashmap, and dump most of the log upon success. on error, actually serialize the cheap log.

clojure DSL for SQL and entities