Friday, April 16, 2010
Scott Davis - First Time at Philly Emerging Tech Conference
Scott also participated in the Battle of the Frameworks.
Thursday, April 15, 2010
Lincoln Baxter III - Pretty Faces
Thanks to Dan Allen for suggesting we invite Lincoln this year.
David Black at Philly ETE
The first is entitled, Opinionated is relative: choice and modularity in Rails applications.
The second, Barbara, Demeter, and Don: notes on some CS precepts from a non-scientist programmer, was rated as one of the best talks by one of Chariot's consultants. Very high marks indeed.
I hope you are finding these recaps valuable.
Wednesday, April 14, 2010
More video reports from Philly ETE
Continue to check back for audio feeds, too.
This clip is from John Quillen. John ran the "Open source is a Commercial Enterprise?" panel. We have beaten the licensing aspect of open source to death, plus it is old news. We thought we would give an update to where open source is currently heading.
Joining John are:
Brian Gentile - President and CEO, Jaspersoft
Shaun Connolly - VP Product Management, Springsource Division of VMware
Nicole Engard - Director of Open Source Education, ByWater Solutions
Rob Cardwell - VP of Middleware Technology, Red Hat
John Quillen - VP, Software Engineering, Jacquette Consulting
Lee Faus - Director of Solution Engineering, Alfresco Software
Monday, April 12, 2010
ETE 2010: Cloud Keynote Speech w/Michael Coté of Redmonk now available
RedMonk an industry analyst firm that covers cloud computing and mobile application development, among other areas. They deliver their analysis as open source. From their website:
"RedMonk is the first analyst firm built on open source. We’re dedicated to providing high quality research at no cost, and believe that the dialog that follows is beneficial to us, our community and our clients."A very interesting model! Mr. Coté's talk is called "The Pragmatic Cloud." He discussed the various ways cloud computing has emerged and taken the We have made the session abstract and slides available as well.
Information about Mr. Coté and RedMonk can be found on the firm's website, redmonk.com.
Ken Rimple
host, Chariot TechCast
Enhancing performance on Android devices
Mobile devices are experiencing rapid gains in memory size as well as processing power, but they're certainly not in the same league as hardware we're typically developing software for. At my recent talk for the 2010 ETE conference, the final segment of the presentation focused on some of the performance techniques I'd utilized to enhance the overall user experience. Since the talk ran a bit long, I didn't have the opportunity to go into all the details I was hoping to so I decided to post one in particular here.
The Android platform's primary development language is Java (there's also the ability to utilize native code, but this post's focus is on Java). The Java source is compiled and then converted to run on the Dalvik virtual machine. While again not a focus of this post, it's important to recognize, at least at the time of this writing, that you don't have the capability to specify things like heap size, garbage collector selection, or any of the ergonomics we take for granted in other environments. On the other hand, the platform does offer a rich feature set to execute background work in a concurrent manner; the talk showed the application's usage of AsyncTask, Looper, Handler, and Message constructs. In light of being able to go so far as arbitrary Thread creation, how does one balance between saturation and diminished throughput?
Seasoned developers will be glad to find that the java.util.concurrent packages are at your disposal for Android development. In particular, the ETE app makes use of the ExecutorService. I coded its usage as a Singleton:
package com.chariotsolutions.ete.util;
import java.lang.ref.SoftReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceSingleton {
private SoftReference<ExecutorService>
executorServiceReference =
new SoftReference<ExecutorService>(
createExecutorService());
private static class SingletonHolder {
private static final ExecutorServiceSingleton INSTANCE =
new ExecutorServiceSingleton();
}
private ExecutorServiceSingleton(){}
public static ExecutorServiceSingleton instance() {
return SingletonHolder.INSTANCE;
}
public ExecutorService getExecutorService() {
ExecutorService executorService =
executorServiceReference.get();
if (executorService == null) {
// (the reference was cleared)
executorService = createExecutorService();
executorServiceReference =
new SoftReference<ExecutorService>(executorService);
}
return executorService;
}
private ExecutorService createExecutorService() {
// future devices (or perhaps existing netbooks?)
// will certainly be multi-core:
return Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors()+2);
}
}
A couple points from the code:
- The ExecutorService is wrapped in a SoftReference. In light of the inherent operating constraints, should the resources get tight, the ExecutorService reference will be reclaimed (after all, its usage is only for new data parsing and for searching).
- Using the SingletonHolder approach, we get the added benefit of lazy initialization, another nod toward efforts of being a good citizen on the device.
- The createExecutorService method logic asks the runtime for the number of available processors; future devices will most certainly feature multiple cores.
In conclusion, the Android platform offers some really nice approaches for background and/or concurrent processing. Properly utilizing such techniques will certainly enhance the user experience, and after all, it's all about the user.
Special thanks to Ahsen Jaffer for contributing the "Map" feature of the application!