Archive for the ‘General’ Category
[DevoxxBE2013] Riddle Me This, Android Puzzlers
Stephan Linzner and Richard Hyndman, Google Android Developer Advocates, unravel enigmatic Android behaviors through interactive puzzles. Stephan, an automation aficionado and runner, teams with Richard, a 12-year mobile veteran from startups to operators, to probe component lifecycles, UI quirks, and KitKat novelties. Their session, blending polls and demos, spotlights content providers’ primacy, ViewStub pitfalls, and screen recording tools, arming developers with debugging savvy.
Android’s intricacies, they reveal, demand vigilance: from process spawning to WebView debugging. Live polls engage the audience, transforming head-scratchers into teachable moments.
Component Creation Order and Lifecycle
Stephan kicks off with a poll: which component initializes first post-process spawn? Hands favor activities, but content providers lead—crucial for data bootstrapping.
Richard demos service lifecycles, warning against onCreate leaks; broadcasts’ unregistered crashes underscore registration discipline.
UI Rendering Quirks and Optimizations
ViewStub inflation puzzles Stephan: pre-inflate for speed, but beware null children post-inflation. Richard explores ListView recycling, ensuring adapters populate recycled views correctly to avoid visual glitches.
These gotchas, they stress, demand profiler scrutiny for fluid UIs.
KitKat Innovations and Debugging Aids
KitKat’s screen recording, Richard unveils, captures high-res videos sans root—ideal for demos or Play Store assets. Stephan spotlights WebView debugging: Chrome DevTools inspect remote views, editing CSS live.
Monkey tool’s seeded crashes aid reproducible testing, simulating user chaos.
Interactive Polls and Community Insights
Polls gauge familiarity with overscan modes and transition animations, fostering engagement. The duo fields queries on SurfaceView security and WebView copies, clarifying limitations.
This collaborative format, they conclude, equips developers to conquer Android’s riddles.
Links:
[DevoxxFR2014] or
ls /sys/firmware/efi # exists → UEFI
> **Security Note**: UEFI Secure Boot prevents unsigned kernels from loading—a critical defense in enterprise environments.
### 1.2 Bootloader: GRUB2
[DevoxxBE2013] Business Strategies for Small Independent Developers
Joe Cieplinski, Creative Director at Bombing Brain Interactive, imparts wisdom on navigating the indie development landscape, drawing from his journey with apps like Teleprompt+ and Setlists. A former Apple Store presenter and app designer since 2008, Joe shares monetization tactics, customer engagement, and marketing essentials for sustaining a living through mobile software. His session, infused with anecdotes from his iOS and OS X ventures, underscores premium pricing, in-app purchases, and responsive support as pillars of success.
Indie developers, Joe contends, thrive by treating apps as products with ongoing value. He recounts Bombing Brain’s evolution, from manual support to PDF/iBooks guides, reducing queries while building loyalty. Effective strategies, he illustrates, blend quality delivery with community interaction, turning users into advocates.
Monetization Models and Pricing Wisdom
Joe advocates premium upfront pricing for perceived value, citing Teleprompt+’s $19.99 tagline drawing discerning users. Subscriptions and in-app upgrades, he demos, extend revenue—unlocking features like cloud sync fosters recurring income.
Avoid free apps’ ad pitfalls, Joe warns; targeted promotions on App Store or forums yield better conversions than broad ads.
Customer Support and Resource Creation
Exemplary support, Joe emphasizes, differentiates indies. He shares Tim Mosley’s empathetic responses, turning complaints into testimonials. Comprehensive manuals—100-page PDFs for Teleprompt+—preempt queries, saving time while showcasing depth.
Social media, though secondary for his audience, amplifies reach; Twitter/App.net engagements build rapport.
Building Reputation and Marketing Tactics
Reputation accrues through consistent excellence, Joe asserts. Cross-platform ports, like Teleprompt+ for iPad/iPhone/OS X, expand ecosystems. Collaborations with friends, as in his trio, infuse passion into products.
Marketing favors organic growth: user reviews, niche forums, and targeted outreach outperform paid campaigns for bootstrapped teams.
Lessons from Bombing Brain’s Journey
Joe reflects on x2y’s launch, balancing innovation with sustainability. He urges indies to prioritize joy—his “lifestyle” approach sustains creativity amid challenges.
This blueprint, Joe concludes, equips solo creators for enduring viability in app markets.
Links:
[DevoxxFR2014] Runtime stage
FROM nginx:alpine
COPY –from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
This pattern reduces final image size from hundreds of megabytes to tens of megabytes. **Layer caching** optimization requires careful instruction ordering:
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
Copying dependency manifests first maximizes cache reuse during development.
## Networking Models and Service Discovery
Docker’s default bridge network isolates containers on a single host. Production environments demand multi-host communication. **Overlay networks** create virtual networks across swarm nodes:
docker network create –driver overlay –attachable prod-net
docker service create –network prod-net –name api myapp:latest
Docker’s built-in DNS enables service discovery by name. For external traffic, **ingress routing meshes** like Traefik or NGINX provide load balancing, TLS termination, and canary deployments.
## Persistent Storage for Stateful Applications
Stateless microservices dominate container use cases, but databases and queues require durable storage. **Docker volumes** offer the most flexible solution:
docker volume create postgres-data
docker run -d \
–name postgres \
-v postgres-data:/var/lib/postgresql/data \
-e POSTGRES_PASSWORD=secret \
postgres:13
For distributed environments, **CSI (Container Storage Interface)** plugins integrate with Ceph, GlusterFS, or cloud-native storage like AWS EBS.
## Orchestration and Automated Operations
Docker Swarm provides native clustering with zero external dependencies:
docker swarm init
docker stack deploy -c docker-compose.yml myapp
“`
For advanced workloads, Kubernetes offers:
– Deployments for rolling updates and self-healing.
– Horizontal Pod Autoscaling based on CPU/memory or custom metrics.
– ConfigMaps and Secrets for configuration management.
Migration paths typically begin with stateless services in Swarm, then progress to Kubernetes for stateful and machine-learning workloads.
Security Hardening and Compliance
Production containers must follow security best practices:
– Run as non-root users: USER appuser in Dockerfile.
– Scan images with Trivy or Clair in CI/CD pipelines.
– Apply seccomp and AppArmor profiles to restrict system calls.
– Use RBAC and Network Policies in Kubernetes to enforce least privilege.
Production Case Studies and Operational Wisdom
Spotify manages thousands of microservices using Helm charts and custom operators. Airbnb leverages Kubernetes for dynamic scaling during peak booking periods. The New York Times uses Docker for CI/CD acceleration, reducing deployment time from hours to minutes.
Common lessons include:
– Monitor with Prometheus and Grafana.
– Centralize logs with ELK or Loki.
– Implement distributed tracing with Jaeger or Zipkin.
– Use chaos engineering to validate resilience.
Strategic Impact on DevOps Culture
Docker fundamentally accelerates the CI/CD pipeline and enables immutable infrastructure. Success requires cultural alignment: developers embrace infrastructure-as-code, operations teams adopt GitOps workflows, and security integrates into every stage. Orchestration platforms bridge the gap between development velocity and operational stability.
Links:
[DevoxxBE2013] Part 1: Thinking Functional Style
Venkat Subramaniam, an award-winning author and founder of Agile Developer, Inc., guides developers through the paradigm shift of functional programming on the JVM. Renowned for Functional Programming in Java and his global mentorship, Venkat uses Java 8, Groovy, and Scala to illustrate functional tenets. His session contrasts imperative statements with composable expressions, demonstrating how to leverage lambda expressions and higher-order functions for elegant, maintainable code.
Functional programming, Venkat posits, transcends syntax—it’s a mindset fostering immutability and data flow. Through practical examples, he showcases Groovy’s idiomatic functional constructs and Scala’s expression-driven purity, equipping attendees to rethink application design.
Functional Principles and Expressions
Venkat contrasts statements—imperative, mutation-driven blocks—with expressions, which compute and return values. He demos a Java 8 stream pipeline, transforming data without side effects, versus a loop’s mutability.
Expressions, Venkat emphasizes, enable seamless composition, fostering cleaner, more predictable codebases.
Groovy’s Functional Idioms
Groovy, though not purely functional, excels in functional style, Venkat illustrates. He showcases collect and findAll for list transformations, akin to Java 8 streams, with concise closures.
These idioms, he notes, simplify data processing, making functional patterns intuitive for Java developers.
Scala’s Expression-Driven Design
Scala’s expression-centric nature shines in Venkat’s examples: every construct returns a value, enabling chaining. He demos pattern matching and for-comprehensions, streamlining complex workflows.
This purity, Venkat argues, minimizes state bugs, aligning with functional ideals.
Higher-Order Functions and Composition
Venkat explores higher-order functions, passing lambdas as arguments. A Groovy example composes functions to filter and map data, while Scala’s currying simplifies partial application.
Such techniques, he asserts, enhance modularity, enabling parallelization for performance-critical tasks.
Practical Adoption and Parallelization
Venkat advocates starting with small functional refactors, like replacing loops with streams. He demos parallel stream processing in Java 8, leveraging multi-core CPUs.
This pragmatic approach, he concludes, bridges imperative habits with functional elegance, boosting scalability.
Links:
[DevoxxFR2014] Build stage
FROM node:16 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
[DevoxxFR2014] Docker in Production: Lessons from the Trenches
Lecturer
Jérôme Petazzoni works as a Docker expert and previously served as an engineer at Docker Inc. He brings a strong background in system administration and distributed systems. Jérôme has deployed containerized workloads at scale in production environments. He frequently speaks on container orchestration, security, and operational best practices.
Abstract
This article distills hard-won production experience with Docker, covering networking, persistent storage, orchestration, and security. It examines common operational pitfalls—such as container sprawl, image bloat, and network complexity—and presents proven solutions including multi-stage builds, overlay networks, and Kubernetes integration. Real-world case studies from leading organizations illustrate strategies for achieving reliability, scalability, and security in containerized production systems.
Image Optimization and Build Strategies
Docker images must remain lean to ensure fast deployments and efficient resource usage. Multi-stage builds separate build-time dependencies from runtime artifacts:
“`
[DevoxxBE2013] Part 1: Java EE 7: What’s New in the Java EE Platform
Antonio Goncalves and Arun Gupta, luminaries in Java EE advocacy, deliver a comprehensive exploration of Java EE 7’s advancements, blending simplification with expanded capabilities. Antonio, a senior architect and author of Beginning Java EE 6 Platform with GlassFish 3, collaborates with Arun, Red Hat’s Director of Developer Advocacy and former Java EE pioneer at Sun Microsystems, to unveil WebSocket, JSON processing, and enhanced CDI and JTA features. Their session, rich with demos, highlights how these innovations bolster HTML5 support and streamline enterprise development.
Java EE 7, they assert, refines container services while embracing modern web paradigms. From WebSocket’s real-time communication to CDI’s unified bean management, they showcase practical integrations, ensuring developers can craft scalable, responsive applications.
WebSocket for Real-Time Communication
Antonio introduces WebSocket, a cornerstone for HTML5’s bidirectional connectivity. He demonstrates @ServerEndpoint-annotated classes, crafting a chat application where messages flow instantly, bypassing HTTP’s overhead.
Arun details encoders/decoders, transforming POJOs to wire-ready text or binary frames, streamlining data exchange for real-time apps like live dashboards.
JSON Processing and JAX-RS Enhancements
Arun explores JSON-P (JSR 353), parsing and generating JSON with a fluid API. He demos building JSON objects from POJOs, integrating with JAX-RS’s HTTP client for seamless RESTful interactions.
This synergy, Antonio notes, equips developers to handle data-driven web applications, aligning with HTML5’s data-centric demands.
CDI and Managed Bean Alignment
Antonio unveils CDI’s evolution, unifying managed beans with injectable interceptors. He showcases constructor injection and method-level validation, simplifying dependency management across EJBs and servlets.
Arun highlights JTA’s declarative transactions, enabling @Transactional annotations to streamline database operations, reducing boilerplate.
Simplified JMS and Batch Processing
Arun introduces JMS 2.0’s simplified APIs, demonstrating streamlined message publishing. The new Batch API (JSR 352), Antonio adds, orchestrates chunk-based processing for large datasets, with demos showcasing job definitions.
These enhancements, they conclude, enhance usability, pruning legacy APIs while empowering enterprise scalability.
Resource Definitions and Community Engagement
Antonio details expanded resource definitions, configuring data sources via annotations. Arun encourages JCP involvement, noting Java EE 8’s community-driven roadmap.
Their demos—leveraging GlassFish—illustrate practical adoption, inviting developers to shape future specifications.
Links:
Jetty / Timeout scanning annotations
Case
My application consists in a WAR I deploy on Tomcat or Jetty during the development phase. I execute Eclipse Jetty either in standalone, or via Maven Jetty plugin – most of the time.
On updating and deploying the application on my laptop (which is not my primary development machine), I get the following error with Maven:
[java]java.lang.Exception: Timeout scanning annotations[/java]
Unlike, with a standalone instance of Jetty, the WAR is successfully deployed.
Complete stacktrace
[java]2014-09-08 22:28:50.669:INFO:oeja.AnnotationConfiguration:main: Scanned 1 container path jars, 87 WEB-INF/lib jars, 1 WEB-INF/classes dirs in 65922ms for context o.e.j.m.p.JettyWebAppContext@13bb109{/,[file:/D:/JLALOU/development/forfait-XXX-XXX/XXX-web/src/main/webapp/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/extensions/primefaces-extensions/2.0.0/primefaces-extensions-2.0.0.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/themes/bootstrap/1.0.10/bootstrap-1.0.10.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/primefaces/5.0/primefaces-5.0.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/com/sun/faces/jsf-impl/2.2.6/jsf-impl-2.2.6.jar!/META-INF/resources/],STARTING}{file:/D:/JLALOU/development/forfait-XXX-XXX/XXX-web/src/main/webapp/}
2014-09-08 22:28:50.670:WARN:oejw.WebAppContext:main: Failed startup of context o.e.j.m.p.JettyWebAppContext@13bb109{/,[file:/D:/JLALOU/development/forfait-XXX-XXX/XXX-web/src/main/webapp/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/extensions/primefaces-extensions/2.0.0/primefaces-extensions-2.0.0.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/themes/bootstrap/1.0.10/bootstrap-1.0.10.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/org/primefaces/primefaces/5.0/primefaces-5.0.jar!/META-INF/resources/, jar:file:/C:/Users/jlalou/.m2/repository/com/sun/faces/jsf-impl/2.2.6/jsf-impl-2.2.6.jar!/META-INF/resources/],STARTING}{file:/D:/JLALOU/development/forfait-XXX-XXX/XXX-web/src/main/webapp/}
java.lang.Exception: Timeout scanning annotations
at org.eclipse.jetty.annotations.AnnotationConfiguration.scanForAnnotations(AnnotationConfiguration.java:571)
at org.eclipse.jetty.annotations.AnnotationConfiguration.configure(AnnotationConfiguration.java:441)
at org.eclipse.jetty.webapp.WebAppContext.configure(WebAppContext.java:466)
at org.eclipse.jetty.webapp.WebAppContext.startContext(WebAppContext.java:1342)
at org.eclipse.jetty.server.handler.ContextHandler.doStart(ContextHandler.java:745)
at org.eclipse.jetty.webapp.WebAppContext.doStart(WebAppContext.java:492)
at org.eclipse.jetty.maven.plugin.JettyWebAppContext.doStart(JettyWebAppContext.java:282)
at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:68)
at org.eclipse.jetty.util.component.ContainerLifeCycle.start(ContainerLifeCycle.java:117)
at org.eclipse.jetty.util.component.ContainerLifeCycle.doStart(ContainerLifeCycle.java:99)
at org.eclipse.jetty.server.handler.AbstractHandler.doStart(AbstractHandler.java:60)
at org.eclipse.jetty.server.handler.ContextHandlerCollection.doStart(ContextHandlerCollection.java:154)
at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:68)
at org.eclipse.jetty.util.component.ContainerLifeCycle.start(ContainerLifeCycle.java:117)
at org.eclipse.jetty.util.component.ContainerLifeCycle.doStart(ContainerLifeCycle.java:99)
at org.eclipse.jetty.server.handler.AbstractHandler.doStart(AbstractHandler.java:60)
at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:68)
at org.eclipse.jetty.util.component.ContainerLifeCycle.start(ContainerLifeCycle.java:117)
at org.eclipse.jetty.server.Server.start(Server.java:358)
at org.eclipse.jetty.util.component.ContainerLifeCycle.doStart(ContainerLifeCycle.java:99)
at org.eclipse.jetty.server.handler.AbstractHandler.doStart(AbstractHandler.java:60)
at org.eclipse.jetty.server.Server.doStart(Server.java:325)
at org.eclipse.jetty.maven.plugin.JettyServer.doStart(JettyServer.java:68)
at org.eclipse.jetty.util.component.AbstractLifeCycle.start(AbstractLifeCycle.java:68)
at org.eclipse.jetty.maven.plugin.AbstractJettyMojo.startJetty(AbstractJettyMojo.java:564)
at org.eclipse.jetty.maven.plugin.AbstractJettyMojo.execute(AbstractJettyMojo.java:360)
at org.eclipse.jetty.maven.plugin.JettyRunMojo.execute(JettyRunMojo.java:168)
at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:133)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:208)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:153)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:145)
at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:108)
at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:76)
at org.apache.maven.lifecycle.internal.builder.singlethreaded.SingleThreadedBuilder.build(SingleThreadedBuilder.java:51)
at org.apache.maven.lifecycle.internal.LifecycleStarter.execute(LifecycleStarter.java:116)
at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:361)
at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:155)
at org.apache.maven.cli.MavenCli.execute(MavenCli.java:584)
at org.apache.maven.cli.MavenCli.doMain(MavenCli.java:213)
at org.apache.maven.cli.MavenCli.main(MavenCli.java:157)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:606)
at org.codehaus.plexus.classworlds.launcher.Launcher.launchEnhanced(Launcher.java:289)
at org.codehaus.plexus.classworlds.launcher.Launcher.launch(Launcher.java:229)
at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode(Launcher.java:415)
at org.codehaus.plexus.classworlds.launcher.Launcher.main(Launcher.java:356)[/java]
Explanation
Since the release of 9.1 branch, Jetty server limits the scan time for annotations at 60 seconds, by default.
The exception is raised here: source
[java]boolean timeout = !latch.await(getMaxScanWait(context), TimeUnit.SECONDS);
if (LOG.isDebugEnabled())
{
for (ParserTask p:_parserTasks)
LOG.debug("Scanned {} in {}ms", p.getResource(), TimeUnit.MILLISECONDS.convert(p.getStatistic().getElapsed(), TimeUnit.NANOSECONDS));
LOG.debug("Scanned {} container path jars, {} WEB-INF/lib jars, {} WEB-INF/classes dirs in {}ms for context {}",
_containerPathStats.getTotal(), _webInfLibStats.getTotal(), _webInfClassesStats.getTotal(),
(TimeUnit.MILLISECONDS.convert(System.nanoTime()-start, TimeUnit.NANOSECONDS)),
context);
}
if (timeout)
me.add(new Exception("Timeout scanning annotations"));[/java]
Fix
As a quick fix, on launching Maven, add the option -Dorg.eclipse.jetty.annotations.maxWait=120 (set a higher value if needed):
[java]mvn jetty:run -Dorg.eclipse.jetty.annotations.maxWait=120[/java]
You can also set this property directly in jetty-*.xml configuration files, for webapp or even for a complete server.