Jonathan Lalou's Blog

Archive for the ‘en-US’ Category

Lecturer

Emmanuel Lecharny is a member of the Apache Software Foundation, contributing to projects like Apache Directory Server and Apache MINA. He also mentors incubating projects such as Deft and Syncope. As founder of his own company, he collaborates on OpenLDAP development through partnerships.

Abstract

Emmanuel Lecharny’s presentation delves into the intricacies of network input/output (NIO) in Java, contrasting it with blocking I/O (BIO) and asynchronous I/O (AIO). Through detailed explanations and code examples, he explores concurrency management, scalability, encoding/decoding, and performance in building efficient servers using Apache MINA. The talk emphasizes practical challenges and solutions, advocating framework use to simplify complex implementations while highlighting system-level considerations like buffers and selectors.

Fundamentals of I/O Models: BIO, NIO, and AIO Compared

Lecharny begins by outlining the three primary I/O paradigms in Java: blocking I/O (BIO), non-blocking I/O (NIO), and asynchronous I/O (AIO). BIO, the traditional model, assigns a thread per connection, blocking until data arrives. This simplicity suits low-connection scenarios but falters under high load, as threads consume resources—up to 1MB stack each—leading to context switching overhead.

NIO introduces selectors and channels, enabling a single thread to monitor multiple connections via events like OP_READ or OP_WRITE. This non-blocking approach scales better, handling thousands of connections without proportional threads. However, it requires manual state management, as partial reads/writes necessitate buffering.

AIO, added in Java 7, builds on NIO with callbacks or futures for completion notifications, reducing polling needs. Yet, it demands careful handler design to avoid blocking the callback thread, often necessitating additional threading for processing.

These models address concurrency differently: BIO is straightforward but resource-intensive; NIO offers efficiency through event-driven multiplexing; AIO provides true asynchrony but with added complexity in callback handling.

Building Scalable Servers with Apache MINA: Core Components and Configuration

Apache MINA simplifies NIO/AIO development by abstracting low-level details. Lecharny demonstrates a basic UDP server: instantiate IoAcceptor, bind to a port, and set a handler for messages. The framework manages buffers, threading, and protocol encoding/decoding.

Key components include IoService (for acceptors/connectors), IoHandler (for events like messageReceived), and filters (e.g., logging, protocol codecs). Configuration involves thread pools: one for I/O (typically one thread suffices due to selectors), another for application logic to prevent blocking.

Scalability hinges on proper setup: use direct buffers for large data to avoid JVM heap copies, but heap buffers for small payloads in Java 7 for speed. MINA’s executor filter offloads heavy computations, maintaining responsiveness.

Code example:

DatagramAcceptor acceptor = new NioDatagramAcceptor();
acceptor.setHandler(new MyHandler());
SocketAddress address = new InetSocketAddress(port);
acceptor.bind(address);

This binds a UDP acceptor, ready for incoming datagrams.

Handling Data: Encoding, Decoding, and Buffer Management

Encoding/decoding is pivotal; MINA’s ProtocolCodecFilter uses encoders/decoders for byte-to-object conversion. Lecharny explains cumulative decoding for fragmented messages: maintain a buffer, append incoming data, and decode when complete (e.g., via length prefixes).

Buffers in NIO are crucial: ByteBuffer for data storage, with position, limit, and capacity. Direct buffers (allocateDirect) bypass JVM heap for zero-copy I/O, ideal for large transfers, but allocation is costlier. Heap buffers (allocate) are faster for small sizes.

Performance tests show Java 7 heap buffers outperforming direct ones up to 64KB; beyond, direct excels. UDP limits (64KB max) favor heap buffers.

Partial writes require looping until completion, tracking written bytes. MINA abstracts this, but understanding underlies effective use.

public class LengthPrefixedDecoder extends CumulativeProtocolDecoder {
    protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) {
        if (in.remaining() < 4) return false;
        int length = in.getInt();
        if (in.remaining() < length) return false;
        // Decode data
        return true;
    }
}

This decoder checks for complete messages via prefixed length.

Concurrency and Performance Optimization in High-Load Scenarios

Concurrency management involves separating I/O from processing: MINA’s single I/O thread uses selectors for event polling, dispatching to worker pools. Avoid blocking in handlers; use executors for database queries or computations.

Scalability tests: on a quad-core machine, MINA handles 10,000+ connections efficiently. UDP benchmarks show Java 7 20-30% faster than Java 6, nearing native speeds. TCP may lag BIO slightly due to overhead, but NIO/AIO shine in connection volume.

Common pitfalls: over-allocating threads (match to cores), ignoring backpressure (queue overloads), and poor buffer sizing. Monitor via JMX: MINA exposes metrics for queued events, throughput.

Lecharny stresses: network rarely bottlenecks; focus on application I/O (databases, disks). 10Gbps networks outpace SSDs, so optimize backend.

Practical Examples: From Simple Servers to Real-World Applications

Lecharny presents realistic servers: a basic echo server with MINA requires minimal code—set acceptor, handler, bind. For protocols like LDAP, integrate codecs for ASN.1 encoding.

In Directory Server, NIO enables handling massive concurrent searches without thread explosion. MINA’s modularity allows stacking filters: SSL for security, compression for efficiency.

For UDP-based services (e.g., DNS), similar setup but with DatagramAcceptor. Handle datagram fragmentation manually if exceeding MTU.

AIO variant: Use AsyncIoAcceptor with CompletionHandlers for callbacks, reducing selector polling.

These examples illustrate MINA’s brevity: functional servers in under 50 lines, versus hundreds in raw NIO.

Implications and Recommendations for NIO Adoption

NIO/AIO demand understanding OS-level mechanics: epoll (Linux) vs. kqueue (BSD) for selectors, impacting portability. Java abstracts this, but edge cases (e.g., IPv6) require vigilance.

Performance gains are situational: BIO suffices for <1000 connections; NIO for scalability. Frameworks like MINA or Netty mitigate complexity, encapsulating best practices.

Lecharny concludes: embrace frameworks to avoid reinventing; comprehend fundamentals for troubleshooting. Java 7+ enhancements make NIO more viable, but test rigorously under load.

Relevant Links and Hashtags

Links:

• Video of the lecture
• Emmanuel Lecharny on LinkedIn

Mathieu Ancelin and Matthieu Clochard, software engineers at SERLI specializing in Java EE and modular systems, showcased the synergy between CDI, OSGi, and Weld in their Weld-OSGi framework during DevoxxBE2012. Mathieu, a member of the CDI 1.1 expert group and contributor to projects like GlassFish, collaborated with Matthieu, who focuses on OSGi integrations, to demonstrate how Weld-OSGi simplifies dynamic application assembly without added complexity.

They started with CDI basics, where dependency injection manages component lifecycles via annotations like @Inject. OSGi’s modularity, with bundles as deployment units and a dynamic service registry, complements this by allowing runtime changes. Weld-OSGi bridges them, enabling CDI beans to interact seamlessly with OSGi services.

A demo illustrated bootstrapping Weld-OSGi in an OSGi environment, registering bundles, and using extensions for event handling. They emphasized transparent service interactions, where CDI observes OSGi events for dynamic updates.

Mathieu and Matthieu highlighted Weld-OSGi’s role in making OSGi accessible, countering perceptions of its difficulty by leveraging CDI’s programming model.

Fundamentals of CDI and OSGi Integration

Mathieu explained CDI’s bean management, scopes, and qualifiers for precise injections. Matthieu detailed OSGi’s bundle lifecycle and service registry, where services publish and consume dynamically.

Weld-OSGi embeds CDI containers in OSGi, using extensions to observe bundle events and register services as beans. This allows injecting OSGi services into CDI components effortlessly.

Dynamic Features and Practical Demonstrations

They demonstrated service dynamism: publishing a service updates dependent beans automatically. Unpublishing triggers alternatives or errors, ensuring robustness.

Demos included hybrid applications where Java EE components interact with OSGi bundles via the registry, deploying parts dynamically without restarts.

Future Prospects and Community Engagement

Mathieu discussed ongoing work for hybrid servers like GlassFish, embedding Weld-OSGi for cleaner integrations. They referenced RFC 146, inspired by Weld-OSGi, for native CDI-OSGi support.

Encouraging trials, they pointed to GitHub repositories with examples and documentation, fostering feedback to evolve the framework.

Mathieu and Matthieu’s presentation illustrated Weld-OSGi’s potential to create fully dynamic modular applications, blending CDI’s elegance with OSGi’s power.

Links:

• Mathieu Ancelin on LinkedIn
• SERLI on LinkedIn

Lecturer

Florent Ramière brings over a decade of software development and project management experience. After years in the US at a software editor and a stint at Capgemini upon returning to France, he co-founded Jaxio with Nicolas Romanetti in 2005. Jaxio offers code generation via Celerio; in 2009, they launched SpringFuse.com, an online version. Active in Paris Java scenes like ParisJUG and Coding Dojos.

Abstract

Florent Ramière’s dynamic demonstration navigates enterprise Java development’s complexities, showcasing tools like Maven, Spring, JPA, and more in a live Eclipse session. Emphasizing practical efficiencies for data-heavy applications, he covers CRUD operations, testing, profiling, and CI. The talk reveals techniques for rapid, robust development, highlighting simplicity’s challenges and offering actionable insights for real-world projects.

Setting the Stage: Tools and Environment for Efficient Development

Ramière begins with audience polling: most work on Java EE/Spring applications involving databases, often exceeding 100 tables. He focuses on large-scale management apps, sharing experiences from consulting across projects.

Demonstrating in Eclipse with Jetty embedded, he launches an internationalized app using an in-memory database for independence. Maven builds the project; SpringFuse aggregates best practices.

Key promise: simplicity is hard; knowing tools accelerates work. If nothing new learned, a Mojito offered – or a fun fact on calculating light speed with chocolate.

The app handles accounts: listing, searching, navigating. CRUD dominates; business logic intersperses.

Core Operations: Querying, Validation, and Data Manipulation

Search uses query-by-example: fields like ‘admin’ or ‘Tokyo’ filter results. JPA with Hibernate enables this; Bean Validation ensures integrity.

Editing involves JSF with PrimeFaces for UI: dialogs, calendars, auto-completes. Commons and Guava libraries aid utilities; Lombok reduces boilerplate.

Saving triggers validations: required fields, formats. Excel exports via JXLS; imports validate before persisting.

Full-text search with Hibernate Search (Lucene) indexes entities, supporting fuzzy matches and facets.

@Entity
@Indexed
public class User {
    @Id
    private Long id;
    @Field(index=Index.YES, analyze=Analyze.YES)
    private String name;
    // ...
}

This annotates for indexing, enabling advanced queries.

Testing and Quality Assurance: From Unit to Integration

JUnit with Fest-Assert and Mockito tests services: mocking DAOs, verifying behaviors.

Selenium with Firefox automates UI tests: navigating, filling forms, asserting outcomes.

JMeter scripts load tests: threading simulates users, measuring throughput.

Sonar integrates for code reviews: violations, discussions directly in Eclipse.

@Test
public void testService() {
    User user = mock(User.class);
    when(user.getName()).thenReturn("Test");
    assertEquals("Test", service.getUserName(1L));
}

Mockito example for isolated testing.

Performance and Deployment: Profiling and Continuous Integration

JProfiler attaches for heap/thread analysis: identifying leaks, optimizing queries.

Hudson (now Jenkins) builds via Maven: compiling, testing, deploying WARs.

iSpace visualizes dependencies, aiding architecture.

Profiles manage environments: dev/test/prod configurations.

Navigating Complexities: Best Practices and Pitfalls

Ramière advises command-line Maven for reliability; avoid outdated WTP.

For large schemas, tools like SpringFuse generate CRUD, reducing tedium.

NoSQL suits big data, but relational fits structured needs; patterns transfer.

Embrace profiles for configurations; Git for code reviews alongside Sonar/Gerrit.

Impact of profilers on tests: significant, but use for targeted optimizations via thread dumps.

In conclusion, enterprise Java demands tool mastery for efficiency; simplicity emerges from knowledge.

Links:

• Video of the lecture
• Florent Ramière on LinkedIn

Ilya Grigorik, a Google web performance engineer and developer advocate, unveiled advanced capabilities of Chrome Developer Tools. Ilya, focused on accelerating the web, overwhelmed attendees with tips, dividing into inspection/debugging and performance analysis.

He encouraged hands-on exploration via online slides, emphasizing tools’ instrumentation for pinpointing bottlenecks.

Starting with basics, Ilya showed inspecting elements, modifying DOM/CSS live, and using console for JavaScript evaluation.

Advanced features included remote debugging for mobile, connecting devices to desktops for inspection.

Inspection and Debugging Essentials

Ilya demonstrated breakpoints on DOM changes, XHR requests, and events, pausing execution for analysis.

Color pickers, shadow DOM inspection, and computed styles aid UI debugging.

Console utilities like $0 for selected elements, querySelector, and table formatting enhance interactivity.

JavaScript Profiling and Optimization

CPU profilers capture call stacks, revealing hot spots. Ilya profiled loops, identifying inefficiencies.

Heap snapshots detect memory leaks by comparing allocations.

Source maps map minified code to originals, with pretty-printing for readability.

Network and Resource Analysis

Network panel details requests, with filters and timelines. Ilya explained columns like status, size, showing compression benefits.

WebSocket and SPDY inspectors provide low-level insights.

HAR exports enable sharing traces.

Timeline and Rendering Insights

Timeline records events, offering frame-by-frame analysis of layouts, paints.

Ilya used it to optimize animations, enabling GPU acceleration.

CSS selectors profile identifies slow rules.

Auditing and Best Practices

Audits suggest optimizations like minification, unused CSS removal.

Extensions customize tools further.

Low-Level Tracing and Customization

Chrome Tracing visualizes browser internals, instrumentable with console.time for custom metrics.

Ilya’s session equipped developers with powerful diagnostics for performant, debuggable applications.

Links:

• Ilya Grigorik on LinkedIn

Lecturer

Martin Gorner is passionate about science, technology, coding, and algorithms. He graduated from Mines Paris Tech and spent early years in ST Microelectronics’ computer architecture group. For 11 years, he shaped the eBook market via Mobipocket, which became Amazon Kindle’s software core. Joining Google Developer Relations in 2011, he focuses on entrepreneurship outreach.

Abstract

Martin Gorner’s lecture surveys HTML5’s four animation technologies: CSS3 and SVG for declarative approaches, Canvas and WebGL for programmatic ones. Through live demonstrations and explanations, he elucidates their strengths, limitations, and applications, emphasizing fluidity for user interfaces akin to mobile apps. The presentation, itself HTML5-based, covers transitions, transformations, and shaders, offering practical insights for enhancing web experiences.

Declarative Animations with CSS3: Simplicity and Power

Gorner introduces CSS3 as straightforward: the ‘transition’ property interpolates between states when a CSS value changes. A JavaScript snippet swaps classes (‘begin’ to ‘end’), shifting position and rotation; specifying ‘transition: 1s’ yields smooth 60fps animation.

For continuous loops, ‘animation’ references a ‘@keyframes’ block defining CSS at percentages (0%, 10%, etc.). Over 3 seconds, it interpolates, applying left shifts, scales, and rotations.

Animatable properties include border thickness, opacity (for fades), and geometric transformations via ‘transform’: rotate, scale, skew (distorting axes). Default easing provides appealing velocity profiles; ‘ease-in-out’ accelerates/decelerates naturally.

Prefixes (e.g., -webkit-) are needed for non-standardized specs; tools like prefixfree.js or SASS automate this. CSS3 suits simple, event-triggered or looping effects but lacks complex paths or programmatic control.

Enhancing Vector Graphics: SVG’s Declarative Animation Capabilities

SVG, for vector drawings, supports declarative animations via tags. Paths define curves; animations alter attributes like ‘d’ for shapes or ‘transform’ for motion.

Keyframes in SVG mirror CSS but embed in elements. Motion follows paths with , rotating optionally. Colors animate via ; groups allow collective effects.

SMIL timing enables sequencing: ‘begin’ offsets, ‘dur’ durations, ‘repeatCount’ loops. Events trigger via ‘begin=”element.click”‘. Interactivity shines: JavaScript manipulates attributes for dynamic changes.

SVG excels in scalable graphics with paths, gradients, and masks but remains declarative, limiting real-time computations. Browser support is strong, though IE lags.

<svg width="400" height="200">
  <circle cx="50" cy="50" r="40" fill="red">
    <animate attributeName="cx" from="50" to="350" dur="2s" repeatCount="indefinite"/>
  </circle>
</svg>

This code animates a circle horizontally, illustrating SVG’s embeddability in HTML5.

Programmatic 2D Animations: Canvas for Frame-by-Frame Control

Canvas offers a bitmap context for JavaScript drawing. ‘requestAnimationFrame’ schedules redraws at 60fps, clearing and repainting each frame.

Basic shapes (rectangles, paths) fill or stroke; images draw via ‘drawImage’. For physics, libraries like Box2D simulate collisions, as in a bouncing ball demo.

Compositing modes (e.g., ‘source-over’) layer effects; shadows add depth. Text renders with fonts; patterns tile images.

Canvas suits games or simulations needing calculations per frame, like particle systems. However, it’s bitmap-based, losing scalability, and requires redrawing everything each frame, taxing performance for complex scenes.

const canvas = document.getElementById('myCanvas');
const ctx = canvas.getContext('2d');
function animate() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  ctx.fillStyle = 'blue';
  ctx.fillRect(x, y, 50, 50); // Draw moving rectangle
  x += 1; // Update position
  requestAnimationFrame(animate);
}
animate();

This snippet moves a rectangle, demonstrating frame updates.

Diving into 3D: WebGL’s Programmatic Power with Shaders

WebGL, on Canvas’s ‘webgl’ context, leverages GPU via OpenGL ES. Setup involves shaders: vertex (positioning) and fragment (coloring) in GLSL.

A simple triangle requires vertex buffers, shader compilation, and drawing with ‘drawArrays’. Matrices handle transformations; perspective projection creates 3D illusions.

Textures map images; lighting (Lambert, Phong) computes via normals. Techniques like normal mapping simulate bumps; environment mapping fakes reflections using cube maps.

Libraries like three.js abstract complexities: ‘new THREE.Mesh’ creates objects with materials. Demos show textured, illuminated models without writing shaders.

WebGL enables high-performance 3D, ideal for visualizations or games, but demands graphics knowledge. Browser support grows, though mobile varies.

const gl = canvas.getContext('webgl');
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
gl.shaderSource(vertexShader, `
  attribute vec4 position;
  void main() {
    gl_Position = position;
  }
`);
gl.compileShader(vertexShader);
// Similar for fragment shader, then link program

This initializes a vertex shader, foundational for WebGL.

Choosing the Right Tool: Contexts and Implications for Web Development

Gorner compares: CSS3 for simple declarative effects; SVG for vector precision and interactivity; Canvas for 2D programmatic needs; WebGL for immersive 3D.

Mobile apps set expectations for fluid UIs; HTML5 meets this sans plugins. Prefixes persist but tools mitigate. Performance favors GPU-accelerated methods.

Workshops on AppSpot cover CSS3, Canvas with Box2D, and WebGL, enabling hands-on learning.

In summary, HTML5’s animations enhance intuitiveness, with choices suiting project scales and requirements.

Relevant Links and Hashtags

Links:

• Video of the lecture
• Slides
• Martin Gorner on LinkedIn

Lecturer

Stephan Janssen is a serial entrepreneur who founded the Belgian Java User Group (BeJUG) in 1996, JCS International in 1998, JavaPolis in 2001 (which evolved into Devoxx), and Parleys.com in 2006. With Java experience since 1995, he has developed real-world solutions in finance and manufacturing. Recognized as a BEA Technical Director and Java Champion, he has spoken at numerous conferences worldwide.

Abstract

Stephan Janssen’s address provides an overview of the Devoxx conference family’s growth and announces Parleys.com’s transition to HTML5. Highlighting synergies across editions and new initiatives like Devoxx for Kids, he demonstrates community expansion. The live demonstration of Parleys’ beta version emphasizes accessibility, free content, and user empowerment, signaling a shift toward inclusive, technology-driven knowledge sharing.

The Devoxx Family: Growth and Cross-Cultural Synergies

Janssen reflects on Devoxx’s evolution into a global “family,” fostering friendships and cultural exchanges. From Devoxx Belgium’s blue sweatshirts and volunteer-driven structure to the Paris JUG’s involvement in France, the model relies on steering and program committees plus helpers.

Expansion includes Devoxx UK, with its “Mind the Geek” t-shirts, drawing 500 attendees in London. Collectively, editions attract 5,500 “Devoxxians” annually, a testament to community strength without financial burden on organizers.

A heartfelt initiative is Devoxx for Kids, inspired by Janssen’s son Arthur. October sessions in Flemish and French sparked a “viral” spread to the Netherlands, UK, Toronto, and Norway. Even rebranded events like GCON for Kids advance youth engagement. Notably, 25% participants were girls, addressing gender gaps in IT by inspiring 10-14-year-olds toward engineering careers.

This interconnected network amplifies impact, blending cultures while maintaining local flavors.

Parleys’ HTML5 Evolution: Accessibility and Community Features

Janssen announces Parleys.com’s beta, ditching Flash for HTML5, enabling iPad viewing (phones pending). A key decision: all Devoxx France talks free, removing paywalls to maximize reach post-processing.

Live demo showcases features: anonymous browsing with slide scrubbing for previews; detailed views; related talks via MongoDB for speed. Social integration allows liking/disliking, with wristband likes from events projected online.

Logged-in users get free channels for uploading PDFs, editable metadata, and mashups with YouTube videos via drag-and-drop timelines. This empowers speakers and JUGs to enhance presentations without coding.

To sustain four full-time developers, tiers include Basic (free, unlimited PDFs/videos via YouTube hosting), Pro, and Enterprise. Two-week sprints ensure rapid iterations; feedback panels invite input.

Parleys’ shift democratizes content, leveraging HTML5 for broader, device-agnostic access.

Relevant Links and Hashtags

Links:

• Video of the lecture
• Stephan Janssen on LinkedIn

Koen Aers, a Red Hat engineer driving Eclipse integration for JBoss Forge, alongside guest Ivan St. Ivanov from SAP, explored boosting Java EE 6 development efficiency. Koen, with a background in jBPM and workflow editors, refreshed on Forge’s role in simplifying complex setups for novices.

Forge, a command-line tool using CDI, incrementally adds features to projects. Commands scaffold entities, UI, and services swiftly.

They demonstrated creating a project, adding persistence with JPA, generating entities like Speaker and Session, and scaffolding JSF views.

For tasks beyond built-ins, plugins extend functionality. Ivan showed developing an Envers plugin for auditing, installing it, and applying to entities.

Integration with IDEs like Eclipse opens Forge’s power graphically.

Their demo built a conference app, adding history views with auditing, showcasing rapid enhancements.

Koen and Ivan emphasized Forge’s elevation of productivity, enabling faster iterations.

Introducing Forge and Basic Workflows

Koen explained Forge’s shell for navigating projects, setting up Maven builds, and adding facets like JPA for persistence.xml configuration.

Commands generate entities with fields, relationships via annotations.

Scaffolding and UI Generation

Scaffolding creates CRUD operations and JSF views from entities, deploying to servers like AS7.

They customized views, adding fields and relations.

Extending with Plugins

Ivan illustrated plugin creation: facets detect capabilities, commands execute actions like adding dependencies.

The Envers plugin audited entities, integrating seamlessly.

IDE Integration and Real-World Application

Eclipse plugins embed Forge consoles, enhancing workflows.

In demo, they audited entities, added history beans, and viewed changes, proving incremental power.

Koen and Ivan’s insights highlighted Forge’s transformative impact on Java EE development.

Links:

• Koen Aers on LinkedIn
• Red Hat website

Lecturer

Alexis Moussine-Pouchkine, a veteran of Sun Microsystems, currently serves as a Developer Relations lead at Google in Paris, assisting developers in achieving success. With over a decade at Sun and nearly two years at Oracle, he brings extensive experience in Java ecosystems and cloud technologies.

Abstract

Alexis Moussine-Pouchkine’s presentation examines Java’s evolution and its potential trajectory in cloud computing. Reflecting on historical shifts in technology, he critiques current limitations and advocates for advancements like multi-tenancy and resource management to ensure Java’s relevance. Through industry examples and forward-looking analysis, the talk underscores the need for adaptation to maintain Java’s position amid resource rationalization and emerging paradigms.

Java’s Maturation and the Cloud Imperative

Moussine-Pouchkine opens by recounting his transition from Sun Microsystems to Oracle and then Google, highlighting how each company has shaped computing history. At Sun, innovation abounded but market fit was inconsistent; Oracle emphasized acquisitions over novelty, straining community ties; Google prioritizes engineers, fostering rapid development.

He likens Java’s current state to emerging from adolescence, facing challenges in cloud environments where resource optimization is paramount. Drawing from his engineering school days with strict quotas on compilation and connection time, Alexis contrasts this with Java’s initial promise of freedom and flexibility. Early experiences with Linux provided boundless experimentation, mirroring Java’s liberating potential in 1997.

The speaker invokes historical predictions: IBM’s CEO allegedly foresaw a market for only five computers in 1943, possibly prescient regarding cloud providers. Bill Gates’ 640K memory quip and Greg Papadopoulos’ 2003 vision of five to seven massive global computers underscore consolidation trends. Papadopoulos envisioned entities like Google, eBay, Salesforce, Microsoft, Amazon, and a Chinese cloud, a perspective less radical today given web evolution.

Java’s centrality in tomorrow’s cloud is questioned. While present in many offerings, most implementations remain prototypes, circumventing Java’s constraints. The cloud demands shared resources and concentration of expertise, yet Java’s future here is uncertain, risking obsolescence like COBOL.

Challenges and Necessary Evolutions for Java in Multi-Tenant Environments

A core issue is Java’s adaptation to multi-tenancy, where multiple applications share a JVM without interference. Current JVMs lack robust isolation, leading to inefficiencies in cloud settings. Moussine-Pouchkine notes Java’s success in Android and Chrome, where processes are segregated, but enterprise demands shared instances for cost savings.

He critiques the stalled JSR-284 for resource management, essential for quotas and usage-based billing. Without these, Java lags in cloud viability. Examples like Google’s App Engine illustrate Java’s limitations: no threads, file system restrictions, and 30-second request limits, forcing workarounds.

Commercial solutions emerge: Waratek’s hypervisor on HotSpot, IBM’s J9 VM, and SAP’s container enable multi-tenancy. Yet, quotas remain crucial for responsible computing, akin to not overindulging at a buffet to ensure sustainability.

Java 9 priorities include modularity (Jigsaw), potentially aiding resource management. Cloud Foundry’s varying memory allocations by language highlight Java’s inefficiencies. Moussine-Pouchkine urges a “slider” for JVM scaling, from minimal to robust, without API fractures.

The community, pioneers in agile practices, continuous integration, and dependency management, must embrace modularity and quotas. Java 7 introduced dynamic languages; Java 8 tackles multicore with lambdas. Recent Oracle slides affirm multi-tenancy and resource management in Java 9 and beyond.

Implications for Sustainable and Credible Informatics

Moussine-Pouchkine advocates responsible informatics: quotas foster predictability, countering perceptions of IT as imprecise and costly. Developers, like artisans, must steward tools and design thoughtfully. Over-reliance on libraries (90% bloat) signals accumulated technical debt.

Quotas enhance credibility, enabling commitments and superior delivery. Java’s adaptive history positions it well, provided the community envisions it “caffeinated” – vibrant and adult – rather than “decaffeinated” and stagnant.

In essence, Java must address multi-tenancy and resources to thrive in consolidated clouds, avoiding the fate of outdated technologies.

Relevant Links and Hashtags

Links:

• Video of the lecture
• Alexis Moussine-Pouchkine on LinkedIn

Lecturer

Clarisse Herrenschmidt is a French archaeologist, ancient historian, philologist, and linguist, born October 24, 1946, in Strasbourg. A CNRS researcher since 1979, she is affiliated with the Laboratoire d’Anthropologie Sociale at the Collège de France. She has taught at INALCO (Iranian history, scripts, and graphic cultures) and Paris 8 University (linguistic anthropology). Her book “Les Trois Écritures: Langue, nombre, code” (Gallimard, 2007) won the Georges Dumézil Prize from the Académie Française and the Georges Picot Prize from the Académie des Sciences Morales et Politiques in 2008.

Abstract

Clarisse Herrenschmidt’s lecture surveys 53 centuries of script evolution, from Mesopotamian origins to informatics. Focusing on numeric and monetary inscriptions, she traces innovations from calculi to Indo-Arabic numerals, linking them to societal transformations. Analyzing artifacts as corporeal metaphors, Herrenschmidt reveals scripts’ role in anthropology, economy, and mythology, emphasizing their global yet Western-centric conquest.

Origins in the Ancient Near East: From Calculi to Scripts

Herrenschmidt commences with seventh-millennium BCE calculi – stone/clay objects representing numbers in base-60 systems (sticks for 1, balls for 10, cones for 60). Used for tallying livestock or grain, they stored counts in bowls, aiding memory post-Neolithic shifts to agriculture and pastoralism.

Urban revolutions in Uruk integrated economy, politics, religion, necessitating sealed storage. Clay balls sealed knots on bales/doors; “envelope-bulls” enclosed calculi, representing stored quantities. Seals (e.g., carved stones with birds) identified social actors.

Innovation: marking envelopes’ exteriors with impressions, rendering invisible calculi visible – birthing numerals without destruction. Flat tablets followed: Susa examples bear workshop seals (weaving atelier) and numeric signs (pits for units).

Pictographic tablets added linguistic signs alongside numerals, evolving proto-cuneiform. This rendered invisible visible, foundational for informatics.

Monetary Inscriptions and Geometric-Arithmetic Evolution

Jumping to seventh-century BCE Lydia/Ionia, Herrenschmidt examines coined money: small electrum globules stamped with designs (e.g., lion heads). Coins bore issuer marks and values, disseminating arithmetic-geometric scripts.

Unlike Mesopotamian weight-based metals, coins standardized value via stamps, not weight. Inscriptions (e.g., Persian darics with archer-kings) embodied issuer, value, recipient – a tripartite structure persisting in modern currency.

Indo-Arabic numerals (1-9 from India sixth-seventh centuries CE, zero uniquely Indian) transmitted via Persian-Arabic mathematicians, reached Mediterranean. Sicilian coins (c.1150-55) feature Christ busts, Arabic text, Hijri dates with Indo-Arabic figures.

Fibonacci’s “Liber Abaci” (1202) introduced positional notation, fractions, algebra, geometry, loans/interests – secretly used by merchants despite Church bans.

From Letters of Exchange to Modern Differentiations

Indo-Arabic numerals birthed new money: 1404 letters of exchange – paper-based, metal-free, concealing loans via currency transfers (e.g., Italy to Barcelona). Ancestors of banknotes/checks, unimaginable in Greco-Roman antiquity despite intelligence.

Herrenschmidt notes exhaustion of monetary-arithmetic scripts providing informatics’ terrain. Mathematics developed binary (Leibniz), differentials (Boole), questioning foundations.

Hilbert’s problems (1900-1928): completeness (every statement provable/disprovable? Gödel: no), consistency (avoid absurdities like 1+2=5? Possible), decidability (method to verify assertions? Turing: no).

Informatics and Mythic Corporeal Metaphors

Responses negate mathematics as self-founding language; it differentiates from money (Nixon severs dollar-gold link August 15, 1971, coinciding networks’ rise). Nasdaq’s foundation and TCP/IP (1969-71) mark shifts, though historical-political opacity persists amid U.S. propaganda.

Turing’s 1936 “automatic machine” – theoretical reader-head and infinite tape – conceptualizes computers. Herrenschmidt synthesizes artifacts: envelope-bull (mouth, emitting signs), coin (eye, estimating magnitudes), Turing machine (brain).

These corporeal metaphors underpin script inventions: mouth for numeric/linguistic, eye for grandeur estimation, brain for computation. Humans remain ensnared in mythic bodies emitting/capturing signs, becoming techniques.

Informatics’ third graphic revolution transforms societies and selves, altering habits and constructing beings within immense myths. Developers enact this; observers marvel.

Relevant Links and Hashtags

Links:

• Video of the lecture

Lecturer

Martin Odersky is a professor at EPFL in Lausanne, Switzerland, specializing in programming languages that blend object-oriented and functional paradigms. His research unifies these approaches, evidenced by designs like Pizza, GJ, and Functional Nets. He co-designed Java generics and authored the original javac compiler. Currently, he focuses on Scala, fusing functional and object-oriented programming while ensuring interoperability with Java and .NET.

Abstract

Martin Odersky’s lecture traces object-oriented programming’s (OOP) rise, parallels it with functional programming’s (FP) resurgence, and argues for their synthesis. Analyzing historical catalysts, methodological benefits, and modern hardware demands, he demonstrates how FP addresses parallelism and reactivity challenges. Through Scala examples, Odersky shows OOP and FP as complementary, enhancing modularity and abstraction without mutual exclusion.

Historical Roots and Catalysts for OOP Adoption

Odersky recounts his journey from Pascal compilers to modular languages, Java involvement, and Scala creation. OOP’s mainstreaming, he argues, stemmed not from encapsulation or reuse but practical necessities. Simula (1967) for simulations and Smalltalk (late 1970s) for GUI widgets inverted traditional data structures: fixed operations, unbounded implementations.

In procedural languages like C, this was cumbersome via function pointers; OOP simplified dynamic binding for unknown implementations. Odersky notes early confusion with Smalltalk, mirroring current FP bewilderment. OOP’s advantages – modeling, dependency inversion – emerged post-adoption, sparked by widget programming appeal.

Functional Programming’s Resurgence and Methodological Strengths

FP offers fewer errors, superior modularity, and productivity via higher abstractions and shorter code. Yet, despite 50-year existence, mainstream adoption lagged. Odersky identifies multicore and cloud computing as catalysts: parallelism for hardware utilization, reactivity for asynchronous events, distribution for delays/failures.

Mutable state exacerbates issues like cache coherence and non-determinism in concurrent environments. Immutable data mitigates races, enabling safe caching. Locks/threads scale poorly; even transactions retain problems. FP’s immutability fosters determinism, crucial for scalable systems.

Addressing Modern Computing Challenges with FP

Odersky outlines a triple challenge: parallel, reactive, distributed programming. Mutable state hinders each; FP excels by avoiding it.

For parallelism, he exemplifies mapping developer names: sequential in Scala, parallel via .par, yielding a parallel collection. Side effects risk chaos due to reordered executions, necessitating functional purity for correctness.

Reactivity example: an online store querying users, orders, products, stock. Synchronous calls block threads on slow services, degrading performance. Asynchronous futures prevent blocking; Scala’s for-comprehensions compose them elegantly, hiding complexity. Refactoring for parallelism pairs futures, executing concurrently.

For-comprehensions translate universally to map, flatMap, filter, allowing library-defined interpretations – sequential or async – without polluting domain logic.

Synthesizing OOP and FP: Beyond False Dichotomies

Communities often view OOP and FP oppositely, but Odersky argues orthogonality. Objects modularize (“what goes where”), providing containers with dynamic binding and inheritance. Essential for large codebases (e.g., million-line Scala systems), they prevent global namespace chaos – a Haskell limitation.

Redefine objects: eliminate mutable state dogma (e.g., immutable java.lang.String), structural equality over identity, focus on behavior. Scala embodies this fusion, modeling algebraic types with objects while importing FP capabilities.

Scala unifies scripting (winning JavaOne Script Bowl) and safe, performant systems (core for Twitter, LinkedIn). Odersky concludes OOP/FP synergy enhances development, urging exploration via Scala Days, courses, and talks.

Relevant Links and Hashtags

Links:

• Video of the lecture
• Martin Odersky on LinkedIn