My day three is full of interesting sessions, but this is the only day my evening looks empty - to make time for the After Dark Bash, the official JavaOne party. Motorola's key note is a little disappointing, not much about open development as it's titled and mostly hype. The first technical session is then way better: Eclipse Europa, the next release train of Eclipse platform. The Eclipse people mention this as well, but one of the most extraordinary aspects of these simultaneous releases of Eclipse projects is that while dates are decided 12-18 months before, the releases are always on time. A lot of projects could learn something from that, whether open or closed source. Also the milestone releases are typically very stable from early on. Overall, the size of Eclipse and all Eclipse projects have gone up and there's too many improvements in each one to go over in a one session. There doesn't seem to be anything earth-shattering, but of single plugins that I've heard about, but never bothered to try out, I must bring up Mylar. Mylar's this "active filter" that watches what you are doing in Eclipse and creates dynamic views showing you only the stuff that you are actually interested in.
I skip one session to have just a tiny bit of time to post my notes of the previous day. The next one is OSGi best practices that should come in handy in the future. Eclipse contains an implementation of OSGi, called Equinox, and the plugin and loading architecture is completely based on it. My quick notes explain fairly well what OSGi can do for you, but most applications bigger than Hello-World Applet would benefit from the architecture. Of course the problem is that a few applications want to be architecture-heavy from the beginning and consider these issues while the application is still small. That's why Eclipse RCP is a good choice for a lot of client application projects; you don't need to start from scratch and you have the architecture available when you need it.
My next session is about "Advanced Refactoring in Java platform". I'm really interested in the the topic but the session is mostly a disappointment; the Sun guy is demonstrating the concepts in Netbeans and most of these have been implemented a long time ago in Eclipse, not to mention IntelliJ IDE. In any Netbeans session, you typically hear somebody asking if they could just move to Eclipse. The answer is always the same, but maybe overall it's good that a major player is missing from Eclipse foundation; the competion will push both platforms forward.
I also attend Ning session, which is an interesting architectural presentation. I've been interested in the company for a long time, and while their solutions are not necessarily applicable to other architectures, they re-iterate the known principles: don't over-engineer, a single well-designed system can handle a lot of load, and simple is good.
The last session of the day for me is "Ant to Maven migration", which I picked solely because of the presenter, Jason van Zyl, the creator of Maven. Maven's no silver bullet, but their case study speaks for itself: 21,000 thousand Ant lines were replaced by 3000 lines of Maven code. Obviously, this is a big project. Maven's XML is rather verbose just like Ant's, but it gives you structure and you rarely need to repeat things; both areas where Ant often fails.
Raw notes below
---
Motorola's keynote on open development on Mobile platform
not much about open development.. mostly hype
TS-9920 Eclipse Europa (3.3, WTP 2.0 etc. simultaneous release, like Callisto last year)
for four times in a row (since 3.0) Eclipse has released on time, the last Thursday of June
- commercial projects could learn something from Eclipse
JDT improvements
- Ctrl+Alt to step into
- Ctrl+3 makes available ALL the UI elements; views, menus, etc.
- hyperlink to custom tag declarations
- browser object references/instances (only available on Java SE 6)
- import test runs from your nightly build
- ctrl+space propses unresolved names(!)
- completion in catch clause
- edit>undo for package and other Java views
- visual page designer for jsp and jsf editing
- SWT runs native on Vista WPF (transparent windows, native double-buffering, GPU acceleration, etc.)
BIRT (business reporting)
- jsp page tags and integration with WTP
- word, excel and postscript output
- web services as data sources
Mylar (must check this out)
- focuses the UI to show only infromation relevant to the task-at-hand
- multi-tasking becomes effortless
STP
- service component architecture standard Java code development
- service component architecture SCDL for constructing composites that include services
configurable and extendabl hyperlink detectors
CDT 4.0 new project model
- easily extensible tool chain
- more cpapable indexer
CDT becoming compiled language tooling
- for Ada, C#, Fortran
eclipse for embedded developers
- cdt is just the beginning
DLTK dynamic languages toolkit
- supprot for tcl, ruby, python, javascript
- integrates with mylar and JDT
- major chlalenge: type inference
- a framwork with 20+ extension points, easy to add new dynamic language support
TS-1419 OSGi best practices (good presentation, get the slides)
dynamic modules system for Java
- visibility rules, depndency management, versioning bundles
- installing, starting, stopping, updating, uninstalling all at runtime
service-oriented
- can be registered and sonsumed at runtime
why?
avoid jar file hell
reuse code "out of the box"
simplifies multi-team projects
enables smaller systems
manages deployments locally or remotely
tool support
no lock in - many providers
high adoption rate
osgi layering
services
lifecycle
module
execution environment
os+hardware
security and applications spans through all layers
portable code best practices
- compile your code against the minimum suitable class libraries
- osgi specifies bare minimum execution environment
- your bundle must import all packages that it needs! (except java.*)
miminimize dependencys - use import-package instead of require-bundle
- require-bundle can have only one provider - the named bundle
- import-package can have many providers
- allows for more choices during resolving
- has a lower fan out, which gain adds up quickly
- use version ranges(same as in Maven!)
- design your bundles
hide implementation details
- put implementation details in separate packages from the public API
- do not export the implmentation packages
- avoid class loader hierarchy dependencies
- better to use a safe OSGi model like services or the extender model to have bundles contribute codecs
lifecycle layer best practices
avoid start ordering dependencies
- do not assume that you can always obtain a service during initialization
- use servicetracker to track services and respond to their publication by subclassing
- use a declarative service model like OSGi declarative services or spring OSGi
handle service dynamism
- service is a dynamic entity and can be unpublished after you get it
- use the helpers based on API to watch the event from services
- declarative models for declaring service dependencies with states
whiteboard pattern
don't call us; we call you
design your API to have the listener registered as a service: simple, more robust leverages the OSGI service model
don't use addListener, removeListener (both sides need to implement it, etc.)
the even source tracks the listener services and calls them when there is an event to deliver
OSGi EventAdmin an example of this principle
extender model
- the bundle being "extended" specifies a data schema
- contributing bundles define this data in their bundle
- the extender bundle will track the bundles via a certain lifecycle event and process the data
avoid OSGI framework API coupling
- best practices for any framework
- write your codes as POJOs
- program against interfaces
- isolate the use of OSGi API to a minimal number of classes
- let these coupled classes inject dependencies into the POJOs
- make sure none of your domain clases depen on these OSGi coupled classes
return quickly from framework callbacks
- bundle developers have a tendency to do too muuch up front activation
- lazy is good
- framework callbacks need to return quickly
- use eventing, sping off background thread to perform the long running work
thread safety
- in an OSGi environment, framework callback to your bundle can occur on many differnt threads simultaneously
- your code must be thread-safe!
TS-9861 Advanced Java Refactoring
richer models of the code
catch refactoring options early, the faster you correct, the less the cost
better navigation
more accurate model allows more safe capabilities
semantic modeling very difficult
- accurate type relationships hard
- generic types much harder
- let the compiler guurs figure it all out
ides will rely on compilers for creating the model and getting the errors
refactoring now rarely a separate activity
jackpot executes custom queries
- full access to complete java language semeantic model
- transformers can modifyg query matches
- included rule language
- integrated into netbeans 6.0
TS-6039 web-application development at Ning
TS-7496 Migrating from Ant to Maven
Old stuff for me on Maven benefits...
case study - problems to solve:
- company had almost 25000 Ant lines of code in 129 files, about 6 million lines of Java code
removal of the inner platform effect
adoptions of development infrasturcture standards
ease the cost of deployment
conversion issues
- directory structures
- multi-artifact builds
- checked-in dependencies
- tooling
conversion tools
- nexus - a repository management application that indexes maven repositories and provides a query mechanism to search for artifacts using their MD5 checksum
- tip: do a google search on md5 checksum of a maven artifact
metamorphosis - an adaptable conversion tool (from ant to maven)
result:
- maven build resulted in: 97 pom files, 2910 lines
- eliminated 32 build files and 20502 lines of build logic
- used standard maven plugin to remove most of the build logic and converted their axis tooling wrtten in ant and wrapped it as an ant-based maven plugin
Wednesday. I have an absolute full day from 8.30 till 11pm. I miss Oracle's keynote on 10g because I keep talking with a friend of mine at the breakfast about Java development on a mobile platform. My first techinal session is "Web Beans update", purely chosen because of the speakers, Gavin King and Bob Lee (if you don't know who these guys are, you are probably not developing Java web apps). It's an interesting session on this effort of unifying the IoC models to make the beans available to various web application frameworks in a standard EE way. I'm sure both of these guys are more than capable of making impact and creating better, practical solutions, but getting the mechanism standardized between all the invested parties... well let's just say my confidence on Java "standards" has taken some hits over the past few years.
I'm also checking out Java Persistence API 2.0. They contain a lot of low-level details of what going to be added, but mostly things that vendors/fore-runners, such as Hibernate, have already added (e.g. persistent lists), so the standard is just keepin up with the implementation extensions. I think that's the only way to make the standars really.
In the afternoon, I'm attending the location API 2.0 JSR update since a friend of mine is working on that; pretty different from my field but interesting stuff. The rest of my sessions are however focused on desktop Java and especially on Eclipse RCP. The RCP session is cool: the guy just goes through a lot of code showing how to implement a complete standalone RCP app. This will hopefully come in handy in a relatively short timeframe. I also go to "project Darkstar", which is Sun's new framework for "massive online" games. Obviously the idea is to strengthen Java's position as a gaming platform, and if I were to guess, mostly in mobile space. Nevertheless, Darkstar's core idea is this persistent storage capable of handling high volume of simultaneous write operations and synchronizing the data on multiple clients. So no relational database there. While targeted as a gaming platform, an "unnamed" vendor had re-implemented their auction system in Darkstart and claimed 15 times better through-put compared to their existing relational db implementation. Not bad at all.
In the evening, I happily skip both Eclipse and Google parties, and go for Howard Lewis Ship's Tapestry 5. I have no notes of the session because Howard simply demoes T5 by writing code with it and the slides he has go through the benefits of the framework which I knew already. While still in development, it's *the* most impressing web application development framework for Java at the moment. There are plenty of other frameworks that may have the wow effect, but none of them are as comprehensive as Tapestry as a whole. The late-night session, starting at 10pm is about Grails, so I don't have a choice but to go there as well. It's interesting to compare Grails to Tapestry. Grails guys openly say the are not a component-oriented framework like Tapestry, which is a immediate turn-off for me, but in comparison, Grails has a much deeper integration to Spring and Hibernate as well as I had expected. Their approach to persistent entities and domain-driven development is very similar to Trails albeit they don't generate the UI for you automatically. Any domain object can be immediately stored as persistent entity and associated rely on Hibernate, just like in Trails.
Day two raw notes:
---
Missed GS Oracle 10g
TS-4089 Web beans update
JSR 299: web beans
web beans address
- need for a unified component model
- managing state, scoping, conversation management
- finding compoennts
- configuration, minimize external configuration via use of annotations
relationship to Java EE
- web beans may be used seamlessley as JSF managed beans
- EJB 3.x components may be web beans
- the core of web beans is being architecte to have no hard dependency on JSF or EJB
all about loose coupling: decouple implementations, lifecycles of collaborationg components, orthogonal concerns
ingredients: API, implementation, scope, name, binding annotations, priority
kinds of components
- stateful and stateless session ends, including webservice endpoints
- entity beans
- any Java class
legal to have multiple implementations of the same compoennts
components have priorities
@Component(type=Greeting.class)
// Specify a unique identifier as Hello is known
@Component(type=Greeting.class, priority=MOCK)
// Moch has a higher priority, so if it exists, it's the preferred implementation
ejb 3.0 spec defined a nice interceptor model that is to be extended to web beans
web beans scopes: no scope, request, session, conversation, application
custom extensions to scope: business process, cluster, method
pico, spring, guice, ejb 3.0 all enject at component instantiation time
seam injects at method invocation time
- via setter or direct field access
- extreme loose coupling
- benefit is that you can define a bean in application scope that has a dependency to a bean in narrower scope (not possible in Spring, JSF, Guice...)
specifying component scope
@SessionScoped @Stateful @Component
custom scopieng
@Dcoumented
@Target(TYPE)
@Retention(RUNTIME)
@ScopeType
use context API to manage the lifecycle
@AroundInvoke
components with multiple roles
@Compoennt(name="user")
@Roles(LoggedIn.class)
... hmm this is interesting take on instance-based security implemented with ORLE
@Comopnent(name="loggedInUser")
using both roles together
@Component class BanUser
finding compoennt by type - used exclusively in Guice
binding annotations
- used to find componets by type
- describ the component
- reusable across types
- not just markes, can have attribute value, e.g. @Named("Gavin")
find by type
@In Service service
TS-4945 Java Persistence 2.0
introduced in JSR 220
surprisingly good response
but some problems in 1.0
2.0 goals
- solidify the standard
- clarifgy open issues
- reduce non-portability aspects
- standardize optional functionality
proposed functionality
- more flexible modeling capabilities (ordered lists, collections of string... mostly implemented in Hibernate already)
- expand ORM
- mapped superclass for embeddables
- in JPA 1.0 @OrderBy sort order when a collection is retrieved, but developers want persistent ordering
- persistent ordering with @Ordered @OrderColumn...
- AccessType(PROPERTY) for ambiguous cases (both field and property level access available)
- unidirectional one-to-many relationships using foreign key mappings current not supported (always using join table)
- add unidirectional one-to-many
inheritance mappings
- currently support single table per class or joined subclass strategy
Java persistence query language
- select still too constrained
- queries are always polymorphic - get that type and all subtypes even if that's not what you intended
- criteria queries: allow "node-wiase" query construction (i.e. "address.city") doens't work in Hib3 currently, I wish it did
unfetched state
- detached entities often have unfetched state and/or relationships
- what happens on access to unfetched state is currently undefined, implementations place different burdens on clients
- entitymanager needs to about the open transaction, either get em while transaction is open or em.joinTranscation()
container-managed extended persistence contexts
- becoming increasingly important to support conversations
- issue: stateful session bean "passivation" - for scaling, failover/replication
validation
@REquired, @Max(240)
user defined
@AdequatelyCompensated
TS-5345 Location based services
80% of wireless subscribers are interested in one of more LBS apps
80% of respondents would leverage personal navigation and LBS content
25% of WCDMA handsets will have GPS by end of 2008
development challenges
- privacy concerns
- slow implemntation of locatoin technologies
- hard to develop applications
JSR 179 standardizing location retrieval on Java ME
JSR 293 standardizing access to location-based services from Java ME
- mapping
- navigation
- geocoding and reverse geocoding
- landmark exchange
sample use case
- route planner
- restaurant locator
- service search
- hikiing trails service
API design details
- defines separate java.microedition.location.services
- provides mechanism to discover and select different service proivders
- allows service request in two modes: provider takes control and handles all communication, or the application is in control
geocoding service provider
- applications control the dialogs shown to the user by the gecodoing service
map service porvider
- applicaiton can request map image with selected items from the map service provider
navigation service
landmark exchange
- the format hasn't been agreed
- also defines a set of global landmark categories
what's the default set of categories?
improves on JSR 179
TS: JSR-3938 The last mile of Java desktop
2GB Heap limit
- actually even less ~1.5GB on Widnows
file chososers - users spend a lot of time with these
JFileChooser just has way less functionality
java.awt.FileDialog native, but restrictive
Licensing
has to use native code
bytecode is readable (and modifiable)
don't force the license check in Java, because it can be bypassed
obfuscation - see progaurd. Cool but a hassle if you like stack traces
digital signing: sign you jars, obfuscate the verification - more native code
desktop GC
useful option: -XX:+UseParallelGC
problems: GC fails to keep up with the user, GC blocks the app intermittently
standard APIs replaced
- printing (can't have sticky printer options)
- imageIO (it's good, but not fast enough, no full image data)
- color management (needed thread-safe color space conversions)
- JavaHelp tool (its HTML renderer is non-standard)
Standard API we replaced
- JOptionPane (accelerator keys don't work, close to Windows default, but not user-friendly)
tips and tricks
- my documents (it's localized)
- find the color profile of a display device
- resovle file "shortcuts" and "aliases"
- bring a window ot the front
mac-specific tips and tricks
- screen menu bar with -Dapple.laf.useScreenMenuBar=true
- application menu - use a native launcher to control the meenu
- sheets
- specialized system properties: showGrowBox, fileDialogForDirectories, brushMetalLook, etc.
- use Quaqua, not Aqua
why LightZone chose Java
- almost all the code is cross-platform
- JAI API works great
- easily integrate third-party libraries wehn needed
- easily integrate native code when needed
Good presentation, check out the slides
TS-3774 Anatomy of an Eclipse RCP Application
Equinox is an OSGi implementation
possible to impelement an RCP stand-alone but one that can be run in other contexts, e.g. as a Eclipse plugin
workspace back end: not intended for RCP applciation, but ties directly into "IDE" behavior
check out Eclipse Mylar - only shows you things you are interested in in Eclipse (only those methods you frequently work on etc.)
Nebula - Eclipse project that provides widgets for Eclipse apps
TS-1786 Writing Games with Project Darkstar
BOF-6563 Tapestry 5
fix for the frustration...
BOF-6133 Grails
custom view technology with GSP and dynamic tag libraries
an extensible plug-in system
used in real projects even currently
API integration
- groovy doesn't introduce new classes that would replace Java classes
uses Spring underneath
clean error reporting
Previous years I've been reasoning why JavaOne is better, so this year, I'll just settle for noting it's good to be here again. Sun general session opens the JavaOne as always, and I'm late because of the horrible traffic... Even though I'm on a motorcycle. Everything else is pretty much the same as previous years and that's a good thing in my books. Sun likes to announce big things in JavaOne and it's no different this year. The biggest thing is JavaFX brand, which by itself doesn't mean anything, but the way I read it, JavaFX Script is positioned as a direct competitor to Flash. Especially because under the same branding, they also publish JavaFX mobile - the same for mobile. I'm writing this the following day, and by now I'm sure "the blogosphere" is full of different takes on JavaFX, so google for more info. While different Java-integrated scripting engines existed even before Java SE 6, the official scripting engine support has validated the approach and created countless new Java scripting projects for specific tasks. So, JavaFX is another one of them, but this time for Sun.. for better or worse. Clearly geared towards multimedia, streaming, and graphics.. and if I'm not wrong, based on vector graphics, hopefully they endors SVG as format.
Besides JavaFX, there's many more interesting announcements in different sessions. Following my tradition, I go for sessions that are extremely bleeding and/or things not in my immediate area - on other things I can always read about from web. I've heard a lot of positive things about Groovy, but that's one language I *haven't* tried yet. Groovy is this "scripting" language that has full interoperability with Java and follows the Java syntax as closely as possible, without the annoyances. So for example, no needless getters and setters, no semi-colons, property-based access to everything etc. Scripting was in quotes, because with Groovy it's up to you: you can run Groovy as interpreted or you can choose to compile Groovy with the Grovvy compiler down to bytecode, indistinguishable from any native Java class. Groovy has been integrated into a number of projects already and I predict a bright future for Groovy.
I skipped most of the "boring" JSF sessions in the afternoon and instead opted out going for some session more out of my immediate area of expertise. I really had fun time in Sun SPOT session, which is Sun's new effort of creating a cheap-but good enough embedded system component, rather than just a single chip. Since laying out the wiring for chips in embedded systems is so expensive, SPOT takes the approach of providing a personal-area network and multiple connectors, like analog-to-digital-inputs, different sensors and a 32-bit ARM CPU running a version of JVM on "bare metal" plus a basic Java framework to handle the inputs. Pretty cool, no? So, they were demoing a home-made WII which didn't go entirely without trouble, but the point is bringing the cost down of building something like it by providing a common platform. Perrone System's "All you want to know about robotics and Java" continued on the same trails. They were focusing on building a higher-level Java framework to handle low-level I/O, like controlling servos or combining readingis of gyroscope and accelerometer so system developers could focus on higher level tasks - like "turn wheels 20 degrees" - rather than dealing with all the different states of servos, "oversteering" etc. In the end, they showed a video with all the applications built on using the framework, among them a car participating a DARPA autonomous driving challenge and side-parking the car by itself! The future truly is here.
The session I needed to stick around till 10pm at Moscone center was however about the ruby-like frameworks in Java: Grails, Sails and Trails. It was rather interesting to hear somebody else talking about a framework you are developing, namely Trails. Even though I noticed his information was a little - since I've been rather active on Trails in the past two monst, most of documentation is completely re-written and there's a lot of other minor improvments - Trails was fairly accurately presented and faired well against the others. However, I was mostly interested in Grails as though I had heard about it, I had never tried it out. Of course, I was looking for synergies there, but as Trails is very much a Tapestry framework, and Grails uses their custom view technology, there isn't a way the projects could be easily combined. Nevertheless, using Groovy for coding Trails is certainly possible and something I might look into in the future in order to make it easier for the users.
As in previous years, my raw notes are in the extended entry
---
JavaOne 2007 Day One
JavaFX Script - direct competitor to Adobe Flash. Scripting language for the rest of the world ("the humanity"). Geared towards multimedia, streaming, graphics.
JavaFX Mobile - Full Java SE on a mobile with JavaFX. Looked interesting actually. Nokia had some demo models available
TS-1742 Groovy
JSR-241
Groovy - Java friendly and feature rich
syntax aligned with J ava, full interoperability with Java classes
Groovy has optional types.
supports smart configs and DSLs, adaptable domain models
Meta-Object Protocol can change structure and behaviour at runtime
Groovy GString, but can use java.lang.String as well
no impedance mismatch with parent language
GroovyC to precompile or runtime compilation
Support for annotations just added - no other Java scripting language does that
Jboss announced integrated Groovy into Seam!
@BefroreClass
@Test, everything in the same "class"
Eclipse plugin for Groovy
Closures, Operators, GPath efficient object navigation, GroovyBeans,
Regular expression support in the language,
replace with calculated values
No primitive types in Groovy
manipulate objects at runtime
Groovy script Evaluation at runtime with Eval
Implements JSR-223 (Bean Scripting Framework)
two lines to consume a web service
grails.org
TS-1780 Sun SPOT
Small Programmable Object Techonlogy
Java on smaller and smaller devices
More portable JVM
Isolate application level
platform for wiress sensor network apps
SPOT processor board
180Mhz 32-bit ARM 920T CPU
Chipcon 24020 radio package
2.4 GHz frequency
IEEE 802.15.4 Low rate PAN protocol
SPOT Demo sensor board
accelerometer, temperature sensor, light sensor, 8 tri-clour LEDs, 2 push-button switches
analog to digital inputs/converters
Squawk virtual machine
no underlying OS, runs on "bare metal"
most of code written in Java programming language
interpreter and low level I/O code written in C
everything else in Java
Java ME CLDC 1.1
Analog input
- Read value with 10-bit resolution via IScalarInput class
accelerometer
- built in 3-axis accelerometer
- scale set to 2G or 6G
solid state gyroscope
- dual-axis
- provides rotational velocity, but some drift creeps in
- X and Y lines connect to ADC pins on SPOT
p5 data glove as demo
removed original chips, replaced with SPOT
compass sensor
3D and virtual reality
VrmlLoader - creates a scene from VRML file
JOGL OpenGL for Java
JOAL OPenAL for Java (Audio...)
Lw3dLoader for Lightwave 3D secenes
ObjectFile for Wavefront.obj files
SPOT interactions
Robot - emulates control of mouse from within application
movement is absolute, rather than relative
determining position
- not so simple with available date
- acceleromoter value changes with tilt
- need to combine gyro date with calibrated accelerometer data
radio positioning
- SPOT sends "ping" radio signal
- take signal strength from multiple basestations
- stability of signal strength is not high
- resolution of position changes is therefore low
client SPOT architecture
- hand interaction module
- positioning module
- communication module
- vibration module
robot translater handles the interaction with the virtual world
cool demo with a glove, lots of problems though
BOF-1692 Introducing the Sun SPOT
check out ts-1786: Writing Darkstart apps
TS-1519 Java robotics
Convergence has made robotics reality
personal and service robots are taking off
Java platform for robotics because
- simplicity in programming
- wealth of software compoennts
- wealth of available software expertise
- hardware and os independence
- scalable hardware support
Java ME platform for robotics
- low-level robotics processing
Java RTS for robotics
- deterministic Java platform processing
- SE grade platform support,
but enabling deterministic and timely processing
MAX: a java technology-based robotics engine
- provides higher-level robotics API
- common across platforms
Vex robotics hobby kit
- motors, r/c command encoders, feedback control
lego-based example
- java platform on lego nxt robotics hobby kit
- tinkering with legos
- replaced lego sensors
Tommy: DARPA Grand challenge AGV
- autonomous desert racing robot
single processor card
- GPS, intertial navigation system
- lasers/RADAR for detection
- brains: commands controllers
- two micro-controllers
- steering/shifting
- throttle/braking
- low-level sensing
- 10 man-months software development time
tommy jr: DARPA urban challenge AGV
- leverage reusable platform
- drop in more navigation rules
- drop in more detection rules
- drop in stereo sensor driver
- java real-time system
- project Sun SPOTs
kartbot: low-cost UGV
- modified go kart, bigger engine, more gas, 35 mph
auto-steering harvester
- autonomous farming
- real driver slowed by controls
- harvesting
- autonomous harvesting
- sense trees and form paths
- closed loop control of steering
- real-time steering controls
UAV terrain scanning
- laser scans of terrain
- fused real time with GPS/INS
- data processed to create point grid
- data acquisition timing is critical
Check the show floor for MAX
industrial automation example
- almost robotics :)
- distributed sensing for industrial automation
BOF-6012 Javascript best practices
- use caution when providing functions in the global namespce of modifying core Javascript objects
Try to use an existing Javascript toolkit
- in 99% of case it doesn't make sense to reinvent the wheel - use existing javascript toolkit
- already worked around numerous incompatibilities between different browsers
- provide useful helpers and general plumbing
- code can be used as style guide
- existing thriving communities which can help in case of problems
- packages, inheritance and modules are emulated.
- in dojo, package is an object, module is a file
- inheritance dojo way: declare, then attach to prototype
- call parent methods: call directly (duh!)
BOF-9843 Grails, Sails and Trails
Ruby on Rails started it all
- convention over configuration, Opinionated software, DRY, test driven development, 80/20 rule, MVC
- ActiveRecord - an internal DSL
coincides with trouble in Java world
- disillusioned with EJB 2.x; code, compile, deploy, restart cycle
sails, trails, grails
sails
- started in 2005
- brings the flavor of raild to java
- viento: custom template engine
- rigging for dependency injection
- generate nice URLs
- promotes easy testing
- templates are closest to Rails than other
- model: hibernate, view: Viento, controller: rigging
- eclipse support
- viento has custom method names, illegal in Java.. sort of same as internal DSL in Ruby
Trails
- heck I know this already..
- check if there's maven groovy plugin
grails
- 1.0 released early 2007
- interoperability with Java key goal
- first cousing of rails
- takes the most inspiration from rails
- design really driven by language
- groovy drives grails
- emphasizes domain driven development
- embrace legacy
- support for more complex relationships with hibernate
- go beyond crud
- half in groovy, half in java
- performance - uses native threads, runs on JVM
- deploys as a war
groovy view (GSP)
- groovy server pages
- creation of custom tags
- groovy taglibs increasing
- controllers - dynamic override
- groovy builders are cool