This is the second in our four part training sessions introducing FenixEdu development for new collaborators.
In this second session, we introduce some of the tools used in FenixEdu development, Eclipse, Git and Maven
This document provides an introduction to Git and common branching models. It begins by defining Git as a distributed revision control system created by Linus Torvalds for Linux kernel development. It then discusses why Git is useful, how it is distributed and optimized for merging, and some key Git concepts like commits, branches, and the local repository structure. The document also outlines common Git commands, workflows like centralized, feature branching, Gitflow and GitHub flow, and how pull requests enable collaboration. It concludes by listing additional Git learning resources.
Mercurial and Git are both distributed version control systems that allow developers to work offline and synchronize changes later. Some key differences are:
- Git has a steeper learning curve due to more commands and concepts, while Mercurial's model is closer to Subversion and easier to migrate to.
- Mercurial has cleaner Windows support as an official Python distribution, while Git has stronger Linux heritage and Windows support through third parties.
- Git allows discarding old branch data to optimize disk usage, while Mercurial requires keeping all revision history locally at all times.
- Both systems effectively support branching and merging, though Git can have irregular performance drops and Mercurial branching is slightly slower.
Overall, Mer
This document provides an introduction to the version control system Git. It defines key Git concepts like the working tree, repository, commit, and HEAD. It explains that Git is a distributed version control system where the full history of a project is available once cloned. The document outlines Git's history, with it being created by Linus Torvalds to replace the commercial BitKeeper tool. It then lists and briefly describes important Git commands for local and collaboration repositories, including config, add, commit, log, diff, status, branch, checkout, merge, remote, clone, push, and pull. Lastly, it covers installing Git and generating SSH keys on Windows for accessing Git repositories.
This document provides an overview of revision control systems and compares centralized (e.g. SVN) and distributed (e.g. Git) systems. It discusses the benefits of Git such as independence from network state, fast performance due to locality, and smaller repository sizes. Basic Git concepts and commands are explained, and different Git workflows including "squash" and branching models are described to provide clarity and workflow control for teams.
A brief description of why decentralised version control (Git, Mercurial, etc) is superior to centralised version control (SVN, CVS, etc), written with SVN users in mind.
136 ultra-fast slides, 10-20 minutes of presentation
This document provides a summary of a mini Git tutorial. It begins with an introduction to version control systems and how they allow users to track changes, revert files, and recover from errors. It then explains the basics of Git, including its three main states (committed, modified, staged), how it stores content addressed by SHA-1 hashes, and the local workflow of modifying, staging, and committing files. The document proceeds to cover installing Git, basic configuration, cloning repositories, recording changes, undoing actions, and working with remote repositories hosted online. It concludes by mentioning how Git stores data as commit snapshots and uses branches to track parallel development lines.
This document provides an overview of using Git for version control. It begins with cloning a project from the internet and creating a local Git project. It then covers committing changes, pushing commits to a remote repository on GitHub, and pulling updates. The document also discusses branching, forking projects on GitHub, and sending pull requests to contribute changes back to the original project.
Git is a distributed revision control and source code management system with an emphasis on speed. Git was initially designed and developed by Linus Torvalds for Linux kernel development. Git is a free software distributed under the terms of the GNU General Public License version 2. This tutorial explains how to use Git for project version control in a distributed environment while working on web-based and non web-based applications development.
This document provides an introduction to GIT. It describes the advantages of GIT over other version control systems like SVN. It explains the basic data model and architecture of GIT including local repositories, branches, and remote repositories. It also covers common GIT commands for configuring, tracking changes, viewing history, sharing changes with others through pushing and pulling. Finally, it provides some tips for using GIT aliases, auto-completion, and external diff/merge tools.
This document provides an introduction to Git and GitFlow workflows. It describes Git as a distributed version control system and compares it to SVN. Key Git concepts and commands are explained such as branches, commits, remote repositories, and tools like SourceTree. The document outlines simple and GitFlow workflows suitable for different team sizes and project types. Branch naming conventions are also defined.
Introduction to Git and Github - Google Developer Student Clubs CET, TrivandrumAbhijitNarayan2
Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. This will be a beginner friendly session where we will explain to you how Git and Github works and how to use it for your future projects as well!
This document provides a brief introduction to Git, a distributed version control system. It describes what Git is and some of its key features, such as tracking changes to files over time, supporting distributed development, efficient object storage, easy branching and merging, and universal public identifiers. The document also discusses some of Git's internal mechanisms, such as SHA-1 hashes to uniquely identify objects, the index cache, and how commits and branches work.
The document provides an overview of Git and its usage. It introduces Git as a source code management and distributed version control system. Key topics covered include setting up Git, creating local and remote repositories, tracking changes using commits, and collaborating through branches and by pushing to remote repositories. The document also includes exercises for readers to practice common Git commands.
BLUG 2012 Version Control for Notes DevelopersMartin Jinoch
This document discusses using version control for Notes developers. It recommends using a version control system like Git or Subversion to track changes made during development. It describes how to set up Git for use with Domino Designer using the EGit plugin. It also discusses using a branching model like git-flow to manage features, releases, and bug fixes. Finally, it provides resources for learning more about version control systems and tools that can be integrated into the development workflow.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
Git allows developers to work on independent branches that can be merged together later. The git branch command creates and manages branches. Git checkout selects a branch to work on and updates the working directory files. Merging uses the git merge command to integrate the history of branches, using either a fast-forward or 3-way merge depending on the branch histories. Merging may result in conflicts that must be manually resolved before completing the merge commit.
This document provides an overview of Git and GitHub for code versioning and sharing. It discusses key Git concepts like branches, commits, and merges. It also demonstrates how to perform basic Git commands from the command line interface. GitHub is presented as a tool for easy collaboration on Git projects through features like forking and pull requests. Overall the document serves as an introduction to using Git and GitHub for researchers and code sharing.
Gitlab ci e kubernetes, build test and deploy your projects like a prosparkfabrik
This document discusses using GitLab CI and Kubernetes together for continuous integration, delivery, and deployment. It provides an overview of Kubernetes and GitLab, describes how to set up a GitLab runner using the Kubernetes executor, and provides an example YAML configuration. It also covers continuous deployment workflows, running GitLab on Kubernetes, and some tips and tricks as well as techniques for troubleshooting Kubernetes and GitLab CI/CD pipelines.
Continuous Deployment with Kubernetes, Docker and GitLab CIalexanderkiel
This document discusses continuous deployment of Clojure services to Kubernetes using Docker and GitLab CI. It provides an overview of Docker, Kubernetes, deploying a sample Clojure service, and configuring GitLab CI for continuous integration and deployment. The sample Clojure service is built as a Docker image, tested using GitLab CI, and deployed to Kubernetes clusters for testing and production using configuration files and GitLab CI pipelines.
This document provides an overview of Git and its basic commands for beginners. It covers installing Git, creating repositories on Bitbucket and GitHub, tracking changes with commands like add, commit, push, pull, and resolving merge conflicts. It also discusses branching, tagging, reverting changes, and ignoring files. Key concepts explained include distributed version control, staging changes, commit histories, and setting up aliases and submodules.
This document provides an introduction to Git, a distributed version control system. It discusses what Git is, its history and general features, how and where it can be used. It then provides a quick overview of installing Git, basic usage through a demo, why Git is advantageous compared to other version control systems like SVN, and some everyday Git commands and tools. Resources for learning more about Git are also listed.
Git 101 Presentation
The presentation introduces Git version control system including:
[1] An overview of version control systems and the basics of Git such as snapshots, local operations, and three main states of files.
[2] A comparison of features between Git and SVN such as distributed development and branching workflows.
[3] Instructions on setting up Git locally and with GitHub, and basic commands for creating and managing repositories, branches, commits, and merges.
Git is a distributed version control system that records changes to files over time. It allows multiple developers to work together and tracks the version history. The document outlines the basic concepts and commands of Git including repositories, commits, branches, merging, cloning, pulling and pushing changes between a local and remote repository. Examples are provided to demonstrate how to initialize a local repository, add and commit changes, switch branches, and push updates to a remote server.
Getting Started with Git: A Primer for SVN and TFS UsersNoam Kfir
I gave this presentation at the Israeli ALM User Group.
This is part 1 of a 2 part series on Git and Git workflows and introduces the most basic Git functionality, especially as it differs from the Subversion and TFS version control systems.
Git is a distributed revision control and source code management system with an emphasis on speed. Git was initially designed and developed by Linus Torvalds for Linux kernel development. Git is a free software distributed under the terms of the GNU General Public License version 2. This tutorial explains how to use Git for project version control in a distributed environment while working on web-based and non web-based applications development.
This document provides an introduction to GIT. It describes the advantages of GIT over other version control systems like SVN. It explains the basic data model and architecture of GIT including local repositories, branches, and remote repositories. It also covers common GIT commands for configuring, tracking changes, viewing history, sharing changes with others through pushing and pulling. Finally, it provides some tips for using GIT aliases, auto-completion, and external diff/merge tools.
This document provides an introduction to Git and GitFlow workflows. It describes Git as a distributed version control system and compares it to SVN. Key Git concepts and commands are explained such as branches, commits, remote repositories, and tools like SourceTree. The document outlines simple and GitFlow workflows suitable for different team sizes and project types. Branch naming conventions are also defined.
Introduction to Git and Github - Google Developer Student Clubs CET, TrivandrumAbhijitNarayan2
Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. This will be a beginner friendly session where we will explain to you how Git and Github works and how to use it for your future projects as well!
This document provides a brief introduction to Git, a distributed version control system. It describes what Git is and some of its key features, such as tracking changes to files over time, supporting distributed development, efficient object storage, easy branching and merging, and universal public identifiers. The document also discusses some of Git's internal mechanisms, such as SHA-1 hashes to uniquely identify objects, the index cache, and how commits and branches work.
The document provides an overview of Git and its usage. It introduces Git as a source code management and distributed version control system. Key topics covered include setting up Git, creating local and remote repositories, tracking changes using commits, and collaborating through branches and by pushing to remote repositories. The document also includes exercises for readers to practice common Git commands.
BLUG 2012 Version Control for Notes DevelopersMartin Jinoch
This document discusses using version control for Notes developers. It recommends using a version control system like Git or Subversion to track changes made during development. It describes how to set up Git for use with Domino Designer using the EGit plugin. It also discusses using a branching model like git-flow to manage features, releases, and bug fixes. Finally, it provides resources for learning more about version control systems and tools that can be integrated into the development workflow.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
Git allows developers to work on independent branches that can be merged together later. The git branch command creates and manages branches. Git checkout selects a branch to work on and updates the working directory files. Merging uses the git merge command to integrate the history of branches, using either a fast-forward or 3-way merge depending on the branch histories. Merging may result in conflicts that must be manually resolved before completing the merge commit.
This document provides an overview of Git and GitHub for code versioning and sharing. It discusses key Git concepts like branches, commits, and merges. It also demonstrates how to perform basic Git commands from the command line interface. GitHub is presented as a tool for easy collaboration on Git projects through features like forking and pull requests. Overall the document serves as an introduction to using Git and GitHub for researchers and code sharing.
Gitlab ci e kubernetes, build test and deploy your projects like a prosparkfabrik
This document discusses using GitLab CI and Kubernetes together for continuous integration, delivery, and deployment. It provides an overview of Kubernetes and GitLab, describes how to set up a GitLab runner using the Kubernetes executor, and provides an example YAML configuration. It also covers continuous deployment workflows, running GitLab on Kubernetes, and some tips and tricks as well as techniques for troubleshooting Kubernetes and GitLab CI/CD pipelines.
Continuous Deployment with Kubernetes, Docker and GitLab CIalexanderkiel
This document discusses continuous deployment of Clojure services to Kubernetes using Docker and GitLab CI. It provides an overview of Docker, Kubernetes, deploying a sample Clojure service, and configuring GitLab CI for continuous integration and deployment. The sample Clojure service is built as a Docker image, tested using GitLab CI, and deployed to Kubernetes clusters for testing and production using configuration files and GitLab CI pipelines.
This document provides an overview of Git and its basic commands for beginners. It covers installing Git, creating repositories on Bitbucket and GitHub, tracking changes with commands like add, commit, push, pull, and resolving merge conflicts. It also discusses branching, tagging, reverting changes, and ignoring files. Key concepts explained include distributed version control, staging changes, commit histories, and setting up aliases and submodules.
This document provides an introduction to Git, a distributed version control system. It discusses what Git is, its history and general features, how and where it can be used. It then provides a quick overview of installing Git, basic usage through a demo, why Git is advantageous compared to other version control systems like SVN, and some everyday Git commands and tools. Resources for learning more about Git are also listed.
Git 101 Presentation
The presentation introduces Git version control system including:
[1] An overview of version control systems and the basics of Git such as snapshots, local operations, and three main states of files.
[2] A comparison of features between Git and SVN such as distributed development and branching workflows.
[3] Instructions on setting up Git locally and with GitHub, and basic commands for creating and managing repositories, branches, commits, and merges.
Git is a distributed version control system that records changes to files over time. It allows multiple developers to work together and tracks the version history. The document outlines the basic concepts and commands of Git including repositories, commits, branches, merging, cloning, pulling and pushing changes between a local and remote repository. Examples are provided to demonstrate how to initialize a local repository, add and commit changes, switch branches, and push updates to a remote server.
Getting Started with Git: A Primer for SVN and TFS UsersNoam Kfir
I gave this presentation at the Israeli ALM User Group.
This is part 1 of a 2 part series on Git and Git workflows and introduces the most basic Git functionality, especially as it differs from the Subversion and TFS version control systems.
Why we ditched TFS and embraced Git, Github, TeamCity and MygetDennis Doomen
For over three years our product development organization has been growing from about 8 developers to the 45 we have now. As a Microsoft oriented organization, the obvious choice has been Team Foundation Server because of it’s many integrated elements such as source control, build environment, work item tracking, dashboards and reporting. However, during the third year the number of concurrent releases increased significantly so we started to get faced with the limitations of its centralized source control.
About 6 months ago, we decided to finally make the switch to Git, a well-known distributed source control approach very popular in the open-source community. Many of us were already active in open-source projects, but introducing git in a large group of people has been, let’s say, interesting. In this session, I’d like to share the approach we took, the challenges we had, and how we solved most of them. Of course I will share the fundamental concepts behind Git and explain you why Git is so much better than a centralized source control solution.
Git introduces the concept of a local repository where the entire project history is stored locally, unlike SVN which routes all changes through a remote repository. With Git, changes are committed as changesets rather than whole file versions, and branching/tagging are inherent parts of distributed version control. Pull requests allow sharing and merging changes between remote and local repositories through fetch, merge, and rebase operations.
Git is a distributed version control system that allows users to track changes to files over time. It keeps a record of the history of changes (revisions) to files in a repository. Each user has their own local copy of the source code repository. Basic Git operations include cloning a remote repository, pulling updates, pushing local changes, creating and switching branches, and merging branches. The document recommends a feature-based workflow for collaborating that involves regularly pulling updates, rebasing local branches, committing changes, merging to master, and pushing changes.
Simple introduction for development teams familiar with Subversion.
Internal presentation licensed as CC-BY-NC-SA. Attribute to this URL or http://fittl.com/ if you re-publish, do *NOT* use commercially.
A Basic Git intro presentation for SVN long timers doing their first steps in Git.
This presentation is meant to clear up most of the basic concepts which cause confusion with developers using Git as if it was an SVN.
This are the slides of my Visug (Visual Studio User Group) session about how yo can leverage the power of Git with TFS 2013/Visual Studio online and Visual Studio.
The document provides an overview of the typical workflow for a Chromium developer, including getting set up with the necessary development environment and tools, obtaining the source code, building and modifying the code, debugging, and submitting changes for review. It discusses using version control systems like Subversion and Git, the Depot Tools for managing the code checkout and uploads, building on different platforms like Linux, Mac and Windows, and common issues that may come up.
Présentation de GIT par Sébastien Dawans, Senior Engineer R&D au Cetic. http://www.cetic.be
Présenté le 26 Novembre 2013 à Louvain-la-Neuve
This document provides tips and techniques for becoming a Git master, including:
1. Creating aliases to simplify common Git commands like committing and adding remotes. Aliases allow parameters and bash functions for complex commands.
2. Using features like assume-unchanged to hide files from Git and rerere to automate resolving similar conflicts.
3. Interactive rebasing to polish commit histories by squashing, rewording, and fixing up commits. Rebasing rewrites history so care is needed.
4. Techniques for preventing history tampering like reject force pushes and signing tags for verification. GPG keys can be stored and imported in Git.
5. Handling project dependencies with build tools or
This document discusses version control systems (VCS) and distributed version control systems (DVCS) like Git. It explains why version control is useful for tracking changes to code, documents, and other projects. Key benefits include backups of different versions, easy access to old versions, and comparing changes between versions. The document then introduces Git as a popular, free, and powerful DVCS and provides examples of basic Git commands like init, add, commit, checkout, branch, and remote repositories.
Slides of a presentation I gave 21 May 2015 for the C++ user group meeting.
http://www.meetup.com/MUCplusplus/events/222396899/
Obevo is an open-source database deployment tool that handles complex database schemas and deployments at enterprise scale. It addresses challenges such as maintaining migration files, determining dependency order, and onboarding existing production databases. Obevo represents database objects as files in a similar structure to code, enables stateful objects through multiple change sections, and uses dependency analysis and topological sorting to determine deployment order. It also supports ORM and in-memory database integration through translation layers.
Real-World Docker: 10 Things We've Learned RightScale
Docker has taken the world of software by storm, offering the promise of a portable way to build and ship software - including software running in the cloud. The RightScale development team has been diving into Docker for several projects, and we'll share our lessons learned on using Docker for our cloud-based applications.
Slide counterparts of video course found here: https://www.youtube.com/playlist?list=PLDshL1Z581YYxLsjYwM25HkIYrymXb7H_
Follow along or just sit back and enjoy a live, hands on tutorial on the power routines of experienced git users. We'll explore with real world examples how to amend commits, do an interactive rebase - and why would you want to do one in the first place, how to solve conflicts without any merge tools, the power of less known merge strategies, how to do interactive commits, and much more.
Course notes
Part 1/8: Introduction
Who am I?
Content overview.
Choice of test project.
Part 2/8: Housekeeping
Find my aliases here.
Enhance your shell with liquidprompt.
Start with an empty commit.
Short cuts to list commits with nice annotations:
Part 3/8: Amending and rebasing
Amend a commit.
Reset a commit to perform a rename.
Different resets affect different parts of a git repository.
Part 4/8: Interactive rebase
How to perform an interactive rebase to remove a binary file stuck in the repository
Part 5/8: Solving conflicts
In this 5th part of the course we'll show a few concepts useful when solving merge and rebase conflicts with an interactive example on how to solve one.
We'll explain --ours, --theirs, conflict markers and what's the process needed to solve a conflict using Git.
Part 6/8: What is a merge and alternative merge strategies
We cover the basics of what a merge is in Git and we show the use of a couple of less known merge strategies like the "ours" merge strategy and the "octopus" strategy.
Part 7/8: Git interactive add
In this part we show how to perform and interactive add using Git. That is splitting the contents of some change across to more semantically meaningful commits.
Part 8/8: How to use Git stash
How to use git stash to solve common workflow situations, swap context with ease and smoothness and look cool to your colleagues.
NYC Kubernetes Meetup Presentation - May 29, 2018
Presentation describes how we use Makefiles to build and deploy microservices on Kubernetes; how code is shared using git submodules; why we chose Helm; how sensitive data is stored in Git.
https://www.meetup.com/New-York-Kubernetes-Meetup/events/250629415
This document discusses different build tools including Ant, Maven, and Gradle. It provides examples of build files for each tool and compares their characteristics such as flexibility, conventions, dependencies management, and extensibility. Ant is described as very flexible but verbose and complex to write and maintain. Maven enforces conventions but has a rigid structure. Gradle combines flexibility, conventions, and extensibility through its Groovy DSL.
This document discusses the benefits of distributed version control systems (DVCS) like Git over centralized version control systems (CVCS) like SVN. It argues that DVCS tools make collaboration and branching much easier and more flexible. Various workflow models for DVCS are presented, including integrating feature branches and using different roles like integration managers. The document provides references for learning more about Git and distributed version control.
Git is a popular distributed version control system that is designed to handle large projects with speed and efficiency. It is "stupidly fast" for local operations and branching/merging. Repositories are also "stupidly small" in size. Git is decentralized, with anyone able to act as a server, and everyone having a full local repository. This allows for benefits like no single point of failure and trivial backups. Git differs from centralized systems like Subversion in ways like its use of the index/staging area and commands like rebase. Overall, Git provides a powerful and flexible system for version control.
Git is a version control system that records changes to files over time so that specific versions can be restored. It allows users to track who made changes to files, what changes were made, and why. Key concepts in Git include repositories that store metadata and file snapshots with each commit. Users can checkout different versions of files, stage files before committing, and collaborate through branching and merging changes.
CDI portable extensions are one of greatest features of Java EE allowing the platform to be extended in a clean and portable way. But allowing extension is just part of the story. CDI opens the door to a whole new eco-system for Java EE, but it’s not the role of the specification to create these extensions.
Apache DeltaSpike is the project that leads this brand new eco-system by providing useful extension modules for CDI applications as well as tools to ease the creation of new ones.
In this session, we’ll start by presenting the DeltaSpike toolbox and show how it helps you to develop for CDI. Then we’ll describe the major extensions included in DeltaSpike, including 'configuration', 'scheduling' and 'data'.
Apache Deltaspike is a collection of CDI extensions that provide features like configuration, exception handling, internationalization, metadata builders, and more. It includes modules for container control, testing, security, scheduling, and data access using repositories. The data module implements the repository pattern and supports JPA out of the box to provide common data access methods and remove boilerplate JPA code.
Саша Белецкий "Continuous Delivery в продуктовой разработке"Agile Base Camp
This document discusses why, how, and when to implement continuous delivery for software projects. It describes how the author used to manually deploy updates for a simple web application, which took 30 minutes to 2 hours and caused customer dissatisfaction. The document then presents the key aspects of continuous delivery: (1) enabling one-click local builds and deployments, (2) defining a source control model with branches for features and releases, and (3) running continuous integration to automatically build, test and deploy changes. It provides examples of tools that can be used to achieve this, such as Jenkins for continuous integration. Implementing these practices resulted in deployment times improving 45 times and site downtimes reducing 300 times.
Generative Artificial Intelligence (GenAI) in BusinessDr. Tathagat Varma
My talk for the Indian School of Business (ISB) Emerging Leaders Program Cohort 9. In this talk, I discussed key issues around adoption of GenAI in business - benefits, opportunities and limitations. I also discussed how my research on Theory of Cognitive Chasms helps address some of these issues
Procurement Insights Cost To Value Guide.pptxJon Hansen
Procurement Insights integrated Historic Procurement Industry Archives, serves as a powerful complement — not a competitor — to other procurement industry firms. It fills critical gaps in depth, agility, and contextual insight that most traditional analyst and association models overlook.
Learn more about this value- driven proprietary service offering here.
Enhancing ICU Intelligence: How Our Functional Testing Enabled a Healthcare I...Impelsys Inc.
Impelsys provided a robust testing solution, leveraging a risk-based and requirement-mapped approach to validate ICU Connect and CritiXpert. A well-defined test suite was developed to assess data communication, clinical data collection, transformation, and visualization across integrated devices.
Massive Power Outage Hits Spain, Portugal, and France: Causes, Impact, and On...Aqusag Technologies
In late April 2025, a significant portion of Europe, particularly Spain, Portugal, and parts of southern France, experienced widespread, rolling power outages that continue to affect millions of residents, businesses, and infrastructure systems.
The Evolution of Meme Coins A New Era for Digital Currency ppt.pdfAbi john
Analyze the growth of meme coins from mere online jokes to potential assets in the digital economy. Explore the community, culture, and utility as they elevate themselves to a new era in cryptocurrency.
This is the keynote of the Into the Box conference, highlighting the release of the BoxLang JVM language, its key enhancements, and its vision for the future.
Semantic Cultivators : The Critical Future Role to Enable AIartmondano
By 2026, AI agents will consume 10x more enterprise data than humans, but with none of the contextual understanding that prevents catastrophic misinterpretations.
Increasing Retail Store Efficiency How can Planograms Save Time and Money.pptxAnoop Ashok
In today's fast-paced retail environment, efficiency is key. Every minute counts, and every penny matters. One tool that can significantly boost your store's efficiency is a well-executed planogram. These visual merchandising blueprints not only enhance store layouts but also save time and money in the process.
Linux Support for SMARC: How Toradex Empowers Embedded DevelopersToradex
Toradex brings robust Linux support to SMARC (Smart Mobility Architecture), ensuring high performance and long-term reliability for embedded applications. Here’s how:
• Optimized Torizon OS & Yocto Support – Toradex provides Torizon OS, a Debian-based easy-to-use platform, and Yocto BSPs for customized Linux images on SMARC modules.
• Seamless Integration with i.MX 8M Plus and i.MX 95 – Toradex SMARC solutions leverage NXP’s i.MX 8 M Plus and i.MX 95 SoCs, delivering power efficiency and AI-ready performance.
• Secure and Reliable – With Secure Boot, over-the-air (OTA) updates, and LTS kernel support, Toradex ensures industrial-grade security and longevity.
• Containerized Workflows for AI & IoT – Support for Docker, ROS, and real-time Linux enables scalable AI, ML, and IoT applications.
• Strong Ecosystem & Developer Support – Toradex offers comprehensive documentation, developer tools, and dedicated support, accelerating time-to-market.
With Toradex’s Linux support for SMARC, developers get a scalable, secure, and high-performance solution for industrial, medical, and AI-driven applications.
Do you have a specific project or application in mind where you're considering SMARC? We can help with Free Compatibility Check and help you with quick time-to-market
For more information: https://www.toradex.com/computer-on-modules/smarc-arm-family
Andrew Marnell: Transforming Business Strategy Through Data-Driven InsightsAndrew Marnell
With expertise in data architecture, performance tracking, and revenue forecasting, Andrew Marnell plays a vital role in aligning business strategies with data insights. Andrew Marnell’s ability to lead cross-functional teams ensures businesses achieve sustainable growth and operational excellence.
Book industry standards are evolving rapidly. In the first part of this session, we’ll share an overview of key developments from 2024 and the early months of 2025. Then, BookNet’s resident standards expert, Tom Richardson, and CEO, Lauren Stewart, have a forward-looking conversation about what’s next.
Link to recording, presentation slides, and accompanying resource: https://bnctechforum.ca/sessions/standardsgoals-for-2025-standards-certification-roundup/
Presented by BookNet Canada on May 6, 2025 with support from the Department of Canadian Heritage.
Special Meetup Edition - TDX Bengaluru Meetup #52.pptxshyamraj55
We’re bringing the TDX energy to our community with 2 power-packed sessions:
🛠️ Workshop: MuleSoft for Agentforce
Explore the new version of our hands-on workshop featuring the latest Topic Center and API Catalog updates.
📄 Talk: Power Up Document Processing
Dive into smart automation with MuleSoft IDP, NLP, and Einstein AI for intelligent document workflows.
Quantum Computing Quick Research Guide by Arthur MorganArthur Morgan
This is a Quick Research Guide (QRG).
QRGs include the following:
- A brief, high-level overview of the QRG topic.
- A milestone timeline for the QRG topic.
- Links to various free online resource materials to provide a deeper dive into the QRG topic.
- Conclusion and a recommendation for at least two books available in the SJPL system on the QRG topic.
QRGs planned for the series:
- Artificial Intelligence QRG
- Quantum Computing QRG
- Big Data Analytics QRG
- Spacecraft Guidance, Navigation & Control QRG (coming 2026)
- UK Home Computing & The Birth of ARM QRG (coming 2027)
Any questions or comments?
- Please contact Arthur Morgan at [email protected].
100% human made.
2. CODE STYLE
When working on a large team, code style is no place
to be creative.
Golden Rule
ALWAYS USE THE GOD DAMN STYLE
Benefits
✓ Minimize the change set on commits and conflicts
✓ Ease the overall readability of the code base
✓ Format the code automatically via IDE save actions
3. SAVE ACTIONS
Save actions allow you to automate a set of tasks that
will
Golden Rule
ALWAYS ENABLE THE GOD DAMN SAVE ACTIONS
Benefits
✓ Code style is applied automatically
✓ Imports are organized according to the same set of rules
✓ Minimize the change set on commits and conflicts
4. BUILD AUTOMATICALLY
When handling big projects, the build automatically
feature can be an unpleasant experience.
Golden Rule
SAY NO TO BUILD AUTOMATICALLY
Benefits
✓ Eclipse will be more responsive
✓ Embedded servlet containers will not react to code changes
✓ Embrace the limitations of FenixFramework
5. ECLIPSE JEDI
If you want to maximize your productivity, you should
use less mouse and more keyboard.
Golden Rule
LEARN YOUR TOOL AND SOME DAMN SHORTCUTS
Benefits
✓ Increase your productivity
✓ Fix and solve your problems quicker
✓ Look smart and geek
6. ECLIPSE JEDI - SHORTCUTS
Some of the most commonly used shortcuts
Ctrl+Space
Auto-complete
Ctrl+Shift+F
Fix Formatting
Ctrl+Shift+R
Open Resource
Ctrl+Shift+T
Open Type
Ctrl+O
Quick Outline
Ctrl+L
Go to Line
Ctrl+T
Quick Hierarchy
8. WHAT IS GIT?
Distributed Version Control System (DVCS) that
provides local branching for free.
Golden Rule
SNAPSHOTS NOT DIFFERENCES
Benefits
✓ Each clone is a safety copy
✓ Local branching is free of headaches
✓ Lots of awesome features (stash, rebase, squash, etc...)
9. SVN VS GIT
Checkins over time
Version 1
SVN
Version 2
file A
Version 3
Δ1
Δ1
Δ1
Version 5
Δ2
file B
file C
Version 4
Δ2
Δ2
Δ3
Checkins over time
Version 1
GIT
Version 2
Version 3
Version 4
Version 5
A
A1
A1
A2
A2
B
B
B
B1
B2
C
C1
C2
C2
C3
10. GIT REPOSITORY
A GIT repository, among other artifacts, is essentially
composed by:
✓ A set of commits
✓ A set of references (pointers) to commits (aka heads)
head A
44d5c
efc3a
a4b4a
d56d4
head B
11. COMMIT
A commit comprehends:
✓ A set of files (blobs) that reflect the state of the project at
a particular time
✓ Reference to the parent commits (i.e. the set of states
from which the new state was originated from)
✓ A SHA1 name which grants the commit unicity and
checksum properties
efc3a
a4b4a
12. HEAD
✓ A reference to a particular commit with a more human
perceptive name
✓ A Git repository can have any number of heads
✓ At a given time, one of the heads is selected as the current
head, which is also a reference called HEAD
head A
44d5c
efc3a
a4b4a
d56d4
head B
HEAD
13. INITIALIZING THE REPOSITORY
Git repositories work using your filesystem
The repository is handled in the .git folder in the root
of your project
$ git init
14. STAGE ONE OR MORE FILES
working
directory
staging
area
git
repository
git checkout
git add
git reset HEAD
git commit
$ touch README.md
$ git add README.md
15. SAVING THE SNAPSHOT (COMMIT)
master
efc3a
HEAD
$ git commit -m “Added README”
34. GITHUB
A service that hosts Git repositories online with extra features
Contribution Methodology
✓ Create forks from other repositories
✓ Push commits to your own fork
✓ Request pulls from your fork (e.g. pull-requests)
35. CLONE
The clone command creates a full copy of the
repository, i.e. all commits, tags and heads.
Clone your fork
$ git clone --origin fork [email protected]:davidmartinho/fenix
(the --origin fork is to name the remote fork instead of the default origin)
Add FenixEdu as a remote to fetch updates
$ git remote add origin https://github.com/FenixEdu/fenix.git
Pull from FenixEdu with rebase to keep history clean
$ git pull --rebase origin master
36. PULL REQUESTS
The pull request is not a git feature.
Github has this pull request feature to improve
contributions and allows developers to merge outside
contributions directly on github.
Golden Rule
ALWAYS MAKE PULL REQUEST ON FENIX
38. WHAT IS MAVEN?
Maven is much more than a project building tool. It
allows you to build and manage your project.
Golden Rule
DEPENDENCIES BINARIES HAVE NO PLACE IN VCS
Benefits
✓ Convention over Configuration
✓ Keeps the VCS repository out of binaries
✓ Format the code automatically via IDE save actions
39. MAVEN BUILDING BLOCKS
LIFECYCLES
Maven knowns how a project is cleaned and built.
A lifecycle is essentially a pre-defined list of phases
to ensure such clean and build processes.
PLUGINS
The phases by themselves are worthless.
We associate plugin goals (implemented by Mojos)
to one of the phases.
40. CLEAN LIFECYCLE
pre-clean
pre-clean
execute necessary tasks prior to
project clean
clean
clean
deletes all files generated during the
building process
post-clean
executes necessary tasks needed
after the building process
post-clean
43. HOW DOES IT WORK?
generate-sources
ff
maven
plugin
maven-compiler-plugin
compile
process-classes
prepare-package
package
install
deploy
44. HOW DOES IT WORK?
generate-sources
ff
maven
plugin
maven-compiler-plugin
compile
process-classes
prepare-package
package
install
deploy
45. HOW DOES IT WORK?
generate-sources
ff
maven
plugin
maven-compiler-plugin
compile
process-classes
prepare-package
maven-jar-plugin
package
install
deploy
46. POM (Project Object Model)
✓ Declarative XML file
✓ Identifies your project (groupId, artifactId, version, packaging)
✓ Declares the project dependencies and their scopes
✓ Declares which plugin goals should run on which phase
✓ Declare additional repositories for the dependencies
47. REPOSITORIES
MAVEN CENTRAL REPOSITORY
Contains most of the commonly known Java
libraries (e.g. log4j, hibernate, jodatime, etc...)
DSI NEXUS REPOSITORY
Contains our binaries (e.g. fenix-framework, tools,
bennu, workflow, organization, etc...)
PROXIED THIRD-PARTY REPOSITORIES
Nexus allows us to proxy and cache some other
third-party repositories. Good when they’re out-ofservice