Archive for the ‘en-US’ Category

Lecturer

Ken Walker, a seasoned software engineer at IBM in Ottawa, Canada, leads the Orion project at the Eclipse Foundation. With extensive experience in software tooling, Walker has been instrumental in advancing web-based development environments. His work focuses on bridging the gap between traditional desktop IDEs and emerging cloud-based solutions, emphasizing accessibility and collaboration. As a key contributor to the Eclipse ecosystem, he leverages IBM’s long-standing involvement in open-source initiatives, including the Eclipse Foundation’s formation in 2004, to drive innovation in developer tools.

Abstract

The transition to cloud-based development environments has promised seamless collaboration, instant access, and reduced setup overhead, yet browser-based Integrated Development Environments (IDEs) like Orion face skepticism from developers accustomed to robust desktop tools such as IntelliJ IDEA or Visual Studio. This lecture, delivered at Devoxx France 2014, explores the reasons behind this resistance, dissecting the technical and usability shortcomings of browser IDEs while highlighting their unique strengths. Through a detailed comparison of desktop and cloud-based development workflows, Ken Walker examines performance bottlenecks, integration challenges, and user experience gaps that deter adoption. He also showcases Orion’s innovative features, such as real-time collaboration and cloud deployment integration, to demonstrate its potential. The discussion concludes with a forward-looking perspective on how evolving web technologies could make browser IDEs indispensable, offering insights for developers considering hybrid workflows in modern software engineering.

The Evolution of IDEs and the Cloud Paradigm Shift

Integrated Development Environments have evolved significantly since the 1980s, when tools like Turbo Pascal provided basic editing and compilation for single languages. The 1990s introduced cross-platform IDEs like Eclipse and NetBeans, which embraced modular architectures to support diverse languages and tools. These desktop IDEs excelled in performance, leveraging local hardware for fast code completion, debugging, and refactoring. However, the rise of cloud computing in the late 2000s sparked a shift toward browser-based IDEs, promising accessibility across devices, automatic updates, and collaborative features akin to Google Docs.

Ken Walker highlights that this shift has not been universally embraced. Developers often find browser IDEs lacking in responsiveness, particularly for tasks like code analysis or large-scale refactoring. This stems from browser sandboxing, which restricts access to local resources, and the inherent limitations of JavaScript execution compared to native applications. For instance, real-time syntax highlighting in a browser IDE may lag when processing thousands of lines, whereas desktop tools like IntelliJ leverage multithreading and local caching for near-instantaneous feedback.

Integration with local development environments poses another challenge. Desktop IDEs seamlessly interact with local file systems, Git clients, and build tools like Maven. In contrast, browser IDEs rely on cloud storage or WebSocket-based synchronization, which can introduce latency or data consistency issues during network disruptions. Walker cites user feedback from the Eclipse community, noting that developers often struggle with configuring browser IDEs to replicate the seamless toolchains of desktop counterparts.

Why Developers Resist Browser IDEs

Walker delves into specific pain points that fuel developer skepticism. One major issue is the lack of feature parity with desktop IDEs. Advanced debugging, a cornerstone of development, is less robust in browser environments. For example, Orion’s debugging relies on remote sessions, which can falter over unstable connections, making it difficult to step through code or inspect complex object states. In contrast, tools like Visual Studio offer graphical debuggers with real-time memory visualization, which browser IDEs struggle to replicate due to browser API constraints.

User experience gaps further compound resistance. Keyboard shortcuts, critical for productivity, often conflict with browser defaults (e.g., Ctrl+S for saving vs. browser save-page functionality), requiring developers to relearn bindings or configure overrides, which vary across browsers like Chrome, Firefox, and Safari. Touch-based devices exacerbate usability issues, as precise cursor placement or multi-line editing becomes cumbersome without mouse input, particularly on tablets.

Collaboration, a touted benefit of browser IDEs, can also disappoint. While real-time editing is possible, poorly handled concurrent changes lead to merge conflicts, especially in large teams. Orion’s Git integration supports basic workflows like commits and pulls, but complex operations like rebasing or resolving merge conflicts lack the intuitive interfaces of desktop tools. Walker acknowledges these issues but argues that they reflect growing pains rather than inherent flaws, as web technologies continue to mature.

Orion’s Strengths and Innovations

Despite these challenges, Orion offers compelling advantages that desktop IDEs struggle to match. Its cloud-native design enables instant project sharing: developers can fork a GitHub repository, edit code in the browser, and push changes without local setup. This lowers barriers for open-source contributors and simplifies onboarding for distributed teams. For example, a developer can share a workspace URL, allowing colleagues to edit code or review changes in real time, a feature that requires additional plugins in desktop IDEs.

Orion integrates seamlessly with cloud platforms like Heroku and AWS, enabling direct deployment from the browser. This streamlines workflows for web developers, who can preview applications without leaving the IDE. Walker demonstrates a live example where a JavaScript application is edited, tested, and deployed to a cloud server in under a minute, showcasing the potential for rapid prototyping.

Recent advancements in web technologies bolster Orion’s capabilities. WebAssembly enables computationally intensive tasks like code analysis to run efficiently in browsers, narrowing the performance gap with native tools. Service workers provide offline support, caching code to allow editing during network outages. Orion’s plugin architecture further enhances flexibility, allowing developers to add custom tools, such as live CSS previews or integration with CI/CD pipelines like Jenkins.

Comparing Desktop and Cloud Workflows

Desktop IDEs excel in performance and integration. IntelliJ IDEA, for instance, uses indexed codebases for instant autocomplete and refactoring across millions of lines. Local Git clients provide robust version control, and native debuggers offer granular control. However, these tools require significant setup—installing Java, configuring plugins, and ensuring compatibility across operating systems—which can hinder collaboration in distributed teams.

Browser IDEs prioritize accessibility. Orion requires only a browser, eliminating installation barriers and ensuring consistency across devices. For educational settings or hackathons, this is transformative: participants can start coding instantly without worrying about Java versions or environment variables. Walker cites Orion’s use in Eclipse community workshops, where novices and experts collaborate seamlessly on shared projects.

The trade-off lies in complexity. Desktop IDEs handle large, monolithic codebases better, while browser IDEs shine for web-focused or lightweight projects. Walker proposes a hybrid model: use browser IDEs for quick edits, prototyping, or collaborative tasks, and desktop IDEs for heavy-duty development like systems programming or enterprise applications.

Future Directions for Browser IDEs

Emerging web standards promise to address current limitations. WebGPU, for instance, will enable hardware-accelerated graphics, improving performance for tasks like code visualization. Progressive Web Apps (PWAs) enhance offline capabilities, making browser IDEs viable in low-connectivity environments. Integration with AI-driven tools, such as GitHub Copilot, could provide intelligent code suggestions, further closing the gap with desktop IDEs.

Walker envisions browser IDEs evolving into primary tools as browser performance approaches native levels. Projects like CodeSandbox and Replit, which emerged post-2014, validate this trajectory, offering robust cloud IDEs with growing adoption. Orion’s open-source nature ensures community-driven enhancements, with plugins for languages like Python and Go expanding its scope.

Conclusion: A Balanced Perspective on Cloud Development

Browser IDEs like Orion represent a paradigm shift, offering unmatched accessibility and collaboration but facing hurdles in performance and integration. While developer resistance is understandable given the maturity of desktop tools, rapid advancements in web technologies suggest a convergence of capabilities. By adopting a hybrid approach—leveraging browser IDEs for lightweight tasks and desktop IDEs for complex projects—developers can maximize productivity. Walker’s talk at DevoxxFR2014 underscores the potential for browser IDEs to reshape development, encouraging the audience to explore tools like Orion while acknowledging areas for improvement.

Links

• Lecture video
• Orion official site
• Eclipse Foundation
• CodeSandbox
• Replit

Lecturers

David Gageot serves as a Developer Advocate at Google, where he focuses on cloud and mobile technologies. Previously a freelance Java developer, he created Infinitest and co-authored books on continuous delivery. Nicolas De Loof consults at CloudBees on DevOps, contributing to Docker as maintainer and organizing Paris meetups.

Abstract

Developing for mobile web requires navigating a landscape of technology choices—native, hybrid, or pure web—while addressing constraints like network latency, disconnection handling, ergonomics, and multi-platform support (iOS, Android, BlackBerry, Windows Phone). This article draws from practical experiences to evaluate these approaches, emphasizing agile methodologies, automated testing, and industrial-strength tooling for efficient delivery. It analyzes performance optimization techniques, UI adaptation strategies, and team organization patterns that enable successful mobile web projects. Through case studies and demonstrations, it provides a roadmap for building responsive, reliable applications that perform across diverse devices and networks.

Technology Choices: Native, Hybrid, or Web

The decision between native development, hybrid frameworks like Cordova, or pure web apps depends on requirements for performance, hardware access, and distribution. Native offers optimal speed but requires platform-specific code; hybrid balances this with web skills; pure web maximizes reach but limits capabilities.

David and Nicolas advocate hybrid for most cases, using Cordova to wrap web apps with native shells for camera, GPS access.

Handling Mobile Constraints

Network latency demands offline capabilities:

if (navigator.onLine) {
    syncData();
} else {
    queueForLater();
}

Ergonomics requires responsive design with media queries:

@media (max-width: 480px) {
    .layout { flex-direction: column; }
}

Multi-Platform Support

Tools like PhoneGap Build compile once for all platforms. Testing uses emulators and cloud services like Sauce Labs.

Agile Team Organization

Small, cross-functional teams with daily standups; automated CI/CD with Jenkins.

Industrialization and Testing

Use Appium for cross-platform tests:

driver.findElement(By.id("button")).click();
assertTrue(driver.findElement(By.id("result")).isDisplayed());

Conclusion: A Practical Roadmap for Mobile Success

Mobile web development succeeds through balanced technology choices, rigorous testing, and agile processes, delivering value across platforms.

Links:

• Lecture video
• Cordova official site
• Appium testing framework

Below is a reworked and comprehensive elaboration of the DevoxxFR2014 conference sessions for chunks 111-114, based on the provided documents. Each section provides an in-depth analysis of the lecture content, lecturer background, technical details, and broader implications, while incorporating relevant links and ensuring full sentences for clarity and depth. The focus is on delivering a thorough and engaging narrative for each talk, tailored to the themes presented at Devoxx France 2014.

At Devoxx France 2015, David Pilato and Colin Surprenant, both deeply involved with Elasticsearch, shared a compelling narrative on leveraging the ELK stack (Elasticsearch, Logstash, Kibana) to transform raw data into actionable insights. David, a French customs service developer, and Colin, an Elasticsearch engineer, demonstrated how they met a marketing team’s data analysis needs in a fraction of the expected time.

Rapid Data Insights with ELK

David recounted a scenario where his marketing team needed to understand customer behavior and sentiment on Twitter. Using Logstash’s Twitter input plugin, he ingested data with simple configuration, leveraging API keys from Twitter’s developer portal. Elasticsearch indexed this data, enabling rapid searches, while Kibana visualized patterns, revealing customer trends in under 30 minutes.

This efficiency, David noted, showcases ELK’s power for real-time analytics.

Handling Dynamic Data Challenges

Colin addressed technical nuances, such as Logstash’s file input managing log rotations intelligently. Their setup handled dynamic file changes, ensuring continuous data flow. Q&A clarified plugin architectures resembling Ruby-like syntax, simplifying configuration. The duo’s approach turned complex data into clear visualizations, freeing time for open-source contributions.

This agility, Colin emphasized, accelerates business decision-making.

Community and Future Engagement

David and Colin invited attendees to a workshop and BOF session, promoting hands-on ELK exploration. Their open-source advocacy, evidenced by David’s RSS River plugin and Elasticsearch community leadership, underscored the stack’s accessibility. They encouraged leveraging GitHub resources for further learning.

This session inspires developers to harness ELK for data-driven solutions.

Links:

• David Pilato on Twitter/X
• David Pilato on GitHub
• Elasticsearch company website

Lecturer

Hadi Hariri has built a distinguished career as a Technical Evangelist at JetBrains, where he promotes IntelliJ IDEA and other development tools through presentations, podcasts, and community engagement. With extensive experience in software architecture and web development, he has authored numerous articles and books while contributing to open-source projects. Based in Spain, Hadi balances his professional life with family responsibilities, including raising three sons, and maintains interests in Tennis and technology evangelism.

Abstract

IntelliJ IDEA represents a pinnacle of integrated development environments, offering an extensive array of features designed to enhance developer productivity across the entire software lifecycle. This presentation delivers a fast-paced overview of 42 essential tips and tricks, though in reality incorporating over 100 individual techniques, each carefully selected to address specific challenges in code navigation, completion, refactoring, debugging, and version control. The article provides a detailed analysis of these features, explaining their implementation mechanics, practical applications, and impact on workflow efficiency. Through live demonstrations and step-by-step breakdowns, it shows how mastering these tools can transform daily development tasks from tedious obligations into streamlined processes, ultimately leading to higher quality code and faster delivery.

Navigation Mastery: Moving Through Code with Precision and Speed

Efficient navigation forms the foundation of productive development in IntelliJ IDEA, allowing users to traverse large codebases with minimal cognitive effort. The Recent Files dialog, accessed via Ctrl+E on Windows or Cmd+E on Mac, presents a chronological list of edited files, enabling quick context switching without manual searching. This feature proves particularly valuable in multi-module projects where related files span different directories, as it preserves mental flow during iterative development cycles.

The Navigate to Class command, triggered by Ctrl+N, allows instant location of any class by typing its name with support for camel-case abbreviation, such as “SC” for StringCalculator. This extends to symbols through Ctrl+Alt+Shift+N, encompassing methods, fields, and variables across the project. These capabilities rely on IntelliJ’s sophisticated indexing system, which builds comprehensive symbol tables upon project load, delivering sub-second search results even in repositories exceeding a million lines of code.

The Structure view, opened with Alt+7, offers a hierarchical outline of the current file’s elements, including methods, fields, and nested classes, with incremental search for rapid location. When combined with the File Structure Popup via Ctrl+F12, developers can navigate complex files without diverting attention from the editor window, maintaining focus during intensive coding sessions.

Code Completion and Generation: Intelligent Assistance for Faster Coding

IntelliJ’s completion system transcends basic auto-suggest by incorporating contextual awareness and type inference to propose relevant options. Basic completion, invoked with Ctrl+Space, suggests identifiers based on scope and visibility, while smart completion via Ctrl+Shift+Space filters to match expected types, preventing invalid assignments and reducing debugging time.

Postfix completion introduces a novel way to wrap expressions with common constructs; for instance, typing “.not” after a boolean generates negation logic, while “.for” creates an iteration loop over collections. This feature streamlines frequent patterns, such as null checks with “.nn” or type casting with “.cast”, integrating seamlessly with the editor’s flow.

Live templates automate repetitive structures; the built-in “sout” expands to System.out.println(), while custom templates can generate complete test methods with annotations and assertions. Hadi demonstrates creating a JUnit template that includes setup code, triggered by a user-defined abbreviation for instant productivity gains.

The generate-from-usage feature, activated with Alt+Enter on undefined elements, creates missing methods, fields, or classes on demand. This supports an intentional coding style where developers first express usage intent, then implement details, aligning perfectly with test-driven development methodologies.

Refactoring Tools: Safe Code Transformation at Scale

Refactoring in IntelliJ maintains program semantics while restructuring code for improved readability and maintainability. The rename refactoring, via Shift+F6, updates all references including comments and string literals when enabled, handling scope conflicts intelligently. Extract method (Ctrl+Alt+M) creates functions from selected code blocks, automatically determining parameters and return types based on usage analysis.

Inline refactoring (Ctrl+Alt+N) reverses extractions, useful for simplifying overly fragmented code while preserving behavior. Change signature (Ctrl+F6) modifies method parameters with propagation to callers, inserting default values for new parameters to avoid compilation errors.

Surround with (Ctrl+Alt+T) wraps selected code in control structures like try-catch or if-else, with template support for custom patterns. These tools collectively enable large-scale code reorganization without manual error-prone adjustments.

Debugging Capabilities: Deep Insight into Runtime Behavior

The debugger provides sophisticated inspection beyond basic stepping. Smart step into (Shift+F7) allows selective entry into chained method calls, focusing on relevant code paths. Evaluate expression (Alt+F8) executes arbitrary code in the current frame, supporting complex debugging scenarios like modifying variables mid-execution.

Drop frame rewinds the call stack, re-executing methods without full restart, ideal for iterative testing of logic branches. Conditional breakpoints pause only when expressions evaluate true, filtering irrelevant iterations in loops.

Lambda debugging treats expressions as methods with full variable inspection and stepping. Custom renderers format complex objects, like displaying collections as comma-separated lists.

Version Control Integration: Streamlined Collaboration

Git support includes visual diffs (Ctrl+D) for conflict resolution, branch management through intuitive dialogs, and cherry-picking from commit histories. The changes view lists modified files with diff previews; annotate shows per-line authorship and revisions.

Interactive rebase through the VCS menu simplifies history cleaning by squashing or reordering commits. Pull request workflows integrate with GitHub, displaying comments directly in the editor for contextual review.

Plugin Ecosystem: Extending Functionality

Plugins like Lombok automate boilerplate with annotations, while Key Promoter X teaches shortcuts through notifications. SonarLint integrates code quality checks, flagging issues in real-time.

Custom plugin development uses Java with SDK support for editor extensions and custom tools.

Advanced Configuration for Optimal Performance

Running on Java 8+ (edit info.plist) improves font rendering. The productivity guide tracks feature usage, helping discover underutilized tools.

Conclusion: IntelliJ as Productivity Multiplier

These techniques collectively transform IntelliJ into an indispensable tool that accelerates development while improving code quality. Consistent application leads to substantial time savings and better software outcomes.

Links:

• Lecture video
• IntelliJ IDEA official site
• JetBrains plugins marketplace

Hubert Sablonnière, a seasoned web developer at INEAT Conseil, captivated audiences at Devoxx France 2015 with a concise yet enlightening session on CSS. With a passion for HTML, CSS, and JavaScript, Hubert debunked the notion that CSS is solely for designers, showcasing its power as a rule-based engine for developers through live coding focused on display, positioning, and floats.

Understanding CSS Layout Principles

Hubert began by challenging the trial-and-error approach to CSS, advocating a structured understanding of its core mechanics. He demonstrated the display property, which dictates how elements like blocks or inline elements behave, forming the foundation of layout design. Positioning, he explained, allows precise placement using static, relative, or absolute modes, while floats enable elements to align side-by-side, transforming rectangular placements into dynamic layouts.

This clarity, Hubert emphasized, empowers developers to craft intentional designs.

Overcoming Common Layout Challenges

Through live coding, Hubert addressed frequent CSS pitfalls, such as containers losing height when child elements float. He showcased solutions like adding a clearing div or using overflow: hidden to restore container dimensions, ensuring visual integrity. His practical tips, grounded in real-world scenarios, illustrated how combining these principles mitigates complexity, making CSS accessible even for those intimidated by styling.

By mastering these fundamentals, Hubert concluded, developers can confidently produce robust layouts.

Links:

• Hubert Sablonnière’s blog

features = full_dataset.apply(advanced_feature_extraction, axis=1)
enhanced_dataset = pd.concat([full_dataset, features], axis=1)

To verify feature efficacy, correlation matrices and PCA are employed, confirming strong discriminatory power.

## Model Selection, Implementation, and Optimization

The binary classification problem—human versus random—lends itself to supervised learning algorithms. Christophe Bourguignat systematically evaluates candidates from linear models to ensembles.

Support Vector Machines provide a strong baseline due to their effectiveness in high-dimensional spaces:

from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

svm_model = SVC(kernel=’rbf’, C=10.0, gamma=0.1, probability=True, random_state=42)
cross_val_scores = cross_val_score(svm_model, X_train, y_train, cv=5, scoring=’roc_auc’)
print(“SVM Cross-Validation AUC Mean:”, cross_val_scores.mean())

svm_model.fit(X_train, y_train)
svm_preds = svm_model.predict(X_test)
print(classification_report(y_test, svm_preds))

Random Forests offer interpretability through feature importance:

rf_model = RandomForestClassifier(n_estimators=500, max_depth=15, random_state=42)
rf_model.fit(X_train, y_train)
rf_importances = pd.DataFrame({
‘feature’: X.columns,
‘importance’: rf_model.feature_importances_
}).sort_values(‘importance’, ascending=False)
print(“Top Features:\n”, rf_importances.head(5))

Gradient Boosting (XGBoost) for superior performance:

from xgboost import XGBClassifier

xgb_model = XGBClassifier(n_estimators=300, learning_rate=0.05, max_depth=8, random_state=42)
xgb_model.fit(X_train, y_train)
xgb_preds = xgb_model.predict(X_test)
print(“XGBoost Accuracy:”, (xgb_preds == y_test).mean())

Optimization uses Bayesian methods via scikit-optimize for efficiency.

## Evaluation and Interpretation

Comprehensive evaluation includes ROC curves, precision-recall plots, and calibration:

from sklearn.metrics import roc_curve, precision_recall_curve

fpr, tpr, _ = roc_curve(y_test, rf_model.predict_proba(X_test)[:,1])
plt.plot(fpr, tpr)
plt.title(‘ROC Curve’)
plt.show()

SHAP values interpret predictions:

import shap

explainer = shap.TreeExplainer(rf_model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test)
“`

Practical Deployment for Geek Use Cases

The model deploys as a Flask API for generating verified random combinations.

Conclusion: Democratizing ML for Everyday Insights

This extended demonstration shows how Python and open data enable geeks to build meaningful ML applications, revealing human biases while providing practical tools.

Links:

• Lecture video
• scikit-learn documentation
• pandas documentation
• OneWinner.me platform

prime_count = sum(1 for n in nums if is_prime(n))
fibonacci_count = sum(1 for n in nums if is_fibonacci(n))

return pd.Series({
    'sum': total_sum,
    'mean': mean_val,
    'std_dev': std_dev,
    'skewness': skewness,
    'kurtosis': kurt,
    'consecutive_count': consec_count,
    'arithmetic_progressions': arith_prog,
    'max_gap': max_gap,
    'min_gap': min_gap,
    'birthday_ratio': birthday_ratio,
    'even_count': even_count,
    'low_half_ratio': low_half / 5.0,
    'prime_count': prime_count,
    'fibonacci_count': fibonacci_count
})

birthday_count = sum(1 for n in nums if 1 <= n <= 31)
birthday_ratio = birthday_count / 5.0
even_count = sum(1 for n in nums if n % 2 == 0)
low_half = sum(1 for n in nums if n <= 25)
high_half = 5 - low_half

consec_count = sum(1 for i in range(4) if nums[i+1] == nums[i] + 1)
arith_prog = sum(1 for i in range(3) if nums[i+2] - nums[i+1] == nums[i+1] - nums[i])
max_gap = max(nums[i+1] - nums[i] for i in range(4))
min_gap = min(nums[i+1] - nums[i] for i in range(4))

Abstract

I am glad and proud to announce the publication of “Android Application Development with Maven”, on March 15th 2015, by Packt.

Direct link: https://www.packtpub.com/apache-maven-dependency-management/book

Alternate locations: Amazon.com, Amazon.co.uk, Barnes & Noble.

On this occasion, I’d like to thank all Packt team for allowing me achieving this project.

What you will learn from this book

• Integrate Maven with your favorite Android IDE
• Install and configure Maven with your local development environment
• Create the proper Maven structure for both standalone Android applications or applications that are part of a bigger project
• Run unit tests using popular frameworks such as Robolectric and collect coverage information using Maven plugins
• Configure a variety of different tools such as Robotium, Spoon, and Selendroid to run integration tests
• Handle dependencies and different versions of the same application
• Manage and automate the release process of your application inside/outside Google Play
• Discover new tools such as Eclipse, IntelliJ IDEA/Android Studio, and NetBeans, which perfectly integrate with Maven and boost your productivity

In Detail

Android is an open source operating system used for smartphones and tablet computers. The Android market is one of the biggest and fastest growing platforms for application developers, with over a million apps uploaded every day.

Right from the beginning, this book will cover how to set up your Maven development environment and integrate it with your favorite IDE. By sequentially working through the steps in each chapter, you will quickly master the plugins you need for every phase of the Android development process. You will learn how to use Maven to manage and build your project and dependencies, automate your Android application testing plans, and develop and maintain several versions of your application in parallel. Most significantly, you will learn how to integrate your project into a complete factory.

Approach

Learn how to use and configure Maven to support all phases of the development of an Android application

Who this book is for

Android Application Development with Maven is intended for Android developers or devops engineers who want to use Maven to effectively develop quality Android applications. It would be helpful, but not necessary, if you have some previous experience with Maven.

Table of content

• 1: Beginning with the Basics
• 2: Starting the Development Phase
• 3: Unit Testing
• 4: Integration Testing
• 5: Android Flavors
• 6: Release Life Cycle and Continuous Integration
• 7: Other Tools and Plugins