TYPO3 CMS Certified Developer (TCCD)

The MVC pattern, what it can be used for, and common implementations.

• I have a basic understanding of what MVC is.

Introduction to the basic concept of a templating engine/processor.

• I can explain what the basic concept of a templating engine is. 
• I can identify needed parts for a templating engine. 

Knowing the most important PSR programming standards in the TYPO3 world.

• I know what PSR is.
• I know the topics the most important standards cover.

Understanding the concept of DDD.

• I know the concept, its purposes and main points.
• I know where to find information to learn more.

Ability to develop and execute PHP scripts.

• I know how to execute PHP scripts in my local environment.
• I know how PHP is executed by a web server.
• I can develop functionality in PHP.

This skill covers the model in the MVC context.

• I know which role models play in the software architectural pattern MVC.

What is a view in MVC context.

• I know which role the view plays in the pattern.

This skill covers the basics of the PHP standard on Event dispatching.

• I know the four use cases of events specified by PSR-14.
• I know about the different components of a PSR-14-compliant event system (Listener, Emitter, Dispatcher, ListenerProvider).
• I know when mutable or immutable events should be used.

Knowledge about dependency injection in general.

• I understand the concept of dependency injection, its benefits and limitations.
• I know when dependency injection should be used.

Definition of Fluid and its possible use with regards to the Model View Controller pattern.

• I can explain what Fluid is. 
• I can define its role in the context of a MVC system. 

Basic usage of variables inside Fluid templates and knowledge about escaping.

• I can find out which variables are passed to a Fluid view.
• I can output variables with the according path syntax.
• I know how Fluid escapes variable output in templates.
• I know how to disable escaping of variables.
• I also know which security risks (XSS) may occure, when disable escaping of variables.

Getting to know what a ViewHelper is.

• I know what ViewHelpers are.
• I know what a Namespace is.
• I can use ViewHelpers in my template.
• I know which ViewHelpers are shipped by stand-alone Fluid, and which are provided by TYPO3 CMS.

Fluid Templates, Layouts, Partials - their interaction and properties.

I know

• what Fluid Templates are
• what Fluid Layouts are
• what Fluid Partials are
• how Templates, Layouts and Partials are connected

I can

• structure Templates, Layouts and Partials
• combine Templates, Layouts and Partials for templating
• use Templates, Layouts and Partials to realise a specific template example

Including comments in Fluid templates.

• I know how to include Fluid comments in my templates.
• I know the difference between HTML comments and Fluid comments regarding the rendered HTML output.

Creating if/else statements within Fluid templates.

• I can create an if/else statement in my templates with the help of the according Fluid ViewHelper.
• I can apply conditions using the inline notation of Fluid.

Iterating through a list with the for ViewHelper.

• I know how to cycle through items with the help of the for ViewHelper inside my Fluid templates.
• I also know how to utilize the iteration object within a cycle.

Using third party ViewHelpers in your Fluid templates.

• I can include third party ViewHelpers in my Fluid templates.
• I know that a TYPO3 Developer can build custom ViewHelpers

Using f:render to render sections and partials as well as passing arguments.

• I can use f:render in my templates to render sections and partials.
• I can pass arguments (along with optional flagging).

Knowing and understanding the different parts of a Fluid template view.

• I understand the API of a Fluid view. 
• I know the public methods that assign variables and template paths. 
• I know the internal API to configure Fluid behaviour. 
• I know the action of rendering a template. 

Using the Fluid ViewHelpers f:link.* and f:uri.*.

• I know the ViewHelpers of the f:link.* family such as f:link.typolink, f:link.email etc. and their important arguments.
• I know the ViewHelpers of the f:uri.* family and their important arguments.
• I know how to use the f:link.* and f:uri.* ViewHelpers properly.

Using Fluid Format ViewHelpers.

• I know how to use Fluid's format ViewHelper and its arguments and purposes.

Using the Fluid ViewHelper f:image().

• I know the important arguments of f:image() ViewHelper (image, src, crop, cropVariant, loading) and how to use the ViewHelper.

The JSON format and its usages in web development.

• I know how to read a JSON file/response.
• I know how to create a valid JSON string with PHP functions.

The built-in JSON View in Extbase.

• I know how the JSON view differs from a normal HTML-based view.
• I know how the JSON view works when the data structure parts are selected for rendering.
• I can configure the JSON output for simple and complex (nested) data structures.

The Fluid-based HTML view of Extbase.

• I know how the Fluid view relates to Fluid.
• I can use layouts and partials in my templates.
• I can configure the view to include templates from multiple directories, with correct priority.

Utilising output to access Fluid variables.

• I know how to use the debug ViewHelper to output variables available to Fluid.
• I know what makes this ViewHelper more appropriate than using a simple echo in my controller.

The TYPO3 CMS form ViewHelper for Fluid.

• I know how Extbase forms can be created in Fluid templates.
• I know how data can be filled into form fields.
• I know how to connect object properties and form fields.
• I can create a form and connect it to an object.
• I can use the different view helpers to create form fields.

Working with XLIFF files in TYPO3 for multilingual websites. Includes writing and extending XLIFF files, overriding translations in TypoScript, and using the f:translate ViewHelper.

• I know what XLIFF is.
• I know how to write and extend an XLIFF file.
• I know how to introduce new languages and generate the needed XLIFF file.
• I know how to override the translations of an extension in TypoScript.
• I know how to access the translations with the f:translate-Viewhelper

Know about transparent inclusion of external file sources into TYPO3.

• I know there is an abstraction layer between actual file storages and their handling in TYPO3.

Basics about the concept of Flexforms and how it relates to the TCA.

• I know what a Flexform data structure is and how it compares to a similar TCA data structure.
• I know how data for a Flexform field is stored.
• I can implement a Flexform data structure in XML.
• I can configure a Flexform field to use my XML data structure.

How to create and configure a data structure for my plugin’s configuration.

• I know how configuration is managed by the “plugin” content type.
• I can provide a custom configuration data structure for my plugin.

Using data provided in FlexForms in plugin CEs and custom records.

• I know how FlexForm data is stored in the database.
• I can extract data from a FlexForm field.
• I can modify the contents of a FlexForm field.

Knowledge about DBMS.

• I know what a DBMS is and what it is used for.
• I can name some examples.
• I know what the term “relational” in the context of DBMS means.

Basic knowledge about the Doctrine component for transparently accessing several DBMS in PHP.

• I know what Doctrine DBAL is.
• I know the difference between Doctrine DBAL and Doctrine ORM.
• I know the role of Doctrine DBAL in TYPO3.

How to write queries in TYPO3.

• I know how to use the QueryBuilder built into TYPO3.
• I know how to write a secure query that can target different DBMS.

How to restrict database queries.

• I know about the restriction containers applied automatically in TYPO3.
• I know the available restrictions and their usage.
• I know how to change which restrictions are applied.

Knowledge about debugging utilities provided by TYPO3.

• I know the built-in mechanics to output debug messages:
  • Extbase DebuggerUtility
  • DebugUtility
  • admin panel
• I know how to add debug output to the frontend.
• I know how to add debug output to the backend.

Knowledge about log sources and how to utilize them in order to resolve errors.

• I know where to look when my instance throws error messages or white pages.
• I know which configuration options define the error output of TYPO3 and Extbase.
• I know how to limit error output to development machines or certain IPs on live instances.

Knowledge about the logging API provided by TYPO3.

• I know how to implement a proper log message and of which parts it consists.
• I know which class to use in order to save messages to dedicated logs

Basic knowledge about error tracing methods in PHP.

• I know about simple methods to print values to output (var_dump, print_r, echo, die).
• I know how to set up and use a debugging tool like Xdebug.

Ability to locate logs provided by system components.

• I know where the main error logs are located.
• I know how to interpret error log messages in order to resolve the error.
• I can access these logs in order to trace errors that occurred in my environment.

This skill covers the PSR standard for HTTP request/response objects.

• I have basic knowledge about the standard PSR-7.
• I know how to deal with request and response objects in PHP.

Extending core and extension functionality without changing code.

• I know what hooks are and the two different types of hook implementations.
• I know the signal/slot pattern, its implementation in TYPO3, and how to apply it.
• I am familiar with PSR-14 Events and I know how to create my own event listeners.
• I know what userFuncs in the TCA are and how to take advantage of them.
• I can identify places where TYPO3 allows to extend built-in functionality.
• I know about XCLASSes, how and when to use them.

Knowledge about the PSR-3 logging standard for PHP.

• I know about the interfaces defined by PSR-3.
• I know about the standard implementations of PSR-3.
• I know the API methods the PSR-3 LoggerInterface provides for writing log messages.
• I can use PSR-3-based logging in my own extensions.

This skill covers the Core's caching framework. It shows how to use existings caches and register custom caches and the types of cache frontends and backends. Additional topics are expiration and tagging of cache entries and flushing of caches.

I can:

• use existing caches
• register and use custom caches
• decide which types of cache frontends and backends to use for which purpose

This skill covers the creation of command-line commands for TYPO3, based on the Symfony Console component.

• I know how to execute existing Symfony CLI commands.
• I can create and register new Symfony CLI commands and find my way around existing commands and can modify them.

This skill covers the Extension Scanner, which extension authors can use to detect possible problems in their extensions while upgrading them to a newer TYPO3 version.

• I can use the Extension Scanner from within the TYPO3 BE and from the command line.
• I know what kind of problems the scanner finds, and the limitations of the scanner.

This skill covers flash messages, a mechanism used to communicate results of an action to the user.

• I know where the Core flash messages and notifications can be used.
• I know which type of flash message to use for what purpose.
• I can create and output flash messages using PHP, HTML and JavaScript in my code.

This skill covers the TYPO3 Mail API, which internally uses Symfony’s Mailer and Mime component for creating and sending emails.

• I can configure the Mail API for different contexts.
• I can create new emails in my extensions and send them through the Mail API.
• I know how to create Fluid-based emails.
• I am familiar with the pros and cons of the different transport methods.

This skill provides knowledge on TYPO3-specific ways of handling errors during program execution and finding information about any errors that occurred.

• I can configure the error and exception handling for development and production.
• I know when errors are handled by the error handler, and where to find any logged errors.

This skill handles basic knowledge of the DataHandler, a TYPO3 Core component for processing user data. It also covers how it can be leveraged in custom developed extensions.

• I know how the DataHandler processes data entered in forms in the Backend.
• I know about hooks I can use for modifying data during processing.
• I know how to use DataHandler in my own extensions (e.g. for mass-creation of records).
• I can modify data during the processing of certain tasks (e.g. versioning).

This skill covers the Symfony Expression syntax used in e.g. TypoScript conditions and ways to extend that functionality with custom code.

• I know the Symfony component "Expression Language" and its syntax.
• I can write and register own ExpressionFunctionProviders.
• I can provide custom TypoScript conditions using my own ExpressionFunctionProviders.
• I also know, that expressions also take place in variant conditions provided by site configuration.

This skill covers the request context and aspects that can be used to enrich this context, e.g. with localization information.

• I know the difference between the ApplicationContext and the Context API.
• I can use the Context API, know which Aspects exist, and can access information from Aspects.
• I know how to add my own Aspects to the Context.

This skill covers the PageTitle API, which can be used to flexibly modify the title of the generated page, e.g. in the single view of a plugin.

• I know about the structure of the PageTitle API.
• I can implement and register custom PageTitleProviders to modify the document's title.

This skill covers the PageRenderer for extension usage, a TYPO3 Core component that is responsible for collecting and generating information about various parts of the page and handling the final output of a page.

• I can use the PageRenderer to modify or extend CSS, JavaScript and other header information in frontend and backend.

This skill covers the MetaTag API, which can be used to manipulate the meta tags in the <head> section of the generated HTML page.

• I can use the MetaTag API to add, modify or remove meta tags.
• I can implement and register my own MetaTagManagers.

This skill covers knowledge on TYPO3’s Environment class, which provides system-specific details that are independent from the system environment.

• I know which kind of information the Environment class in the TYPO3 Core provides.
• I can write code that is not dependent on a specific type of operating system (Windows, Linux, etc.)

This skill covers the registry API, provided by the TYPO3 Core to store instance-specific data.

• I can use the registry API to read and write data.
• I can decide when the registry makes sense to use and when not.

This skill covers the PHP standard on middlewares.

• I know what middlewares and request handlers are specified in PSR-15 and how they relate to each other.

This skill covers the usage of PSR-15 middlewares in TYPO3 - both for frontend and backend request processing.

• I understand how the core leverages middlewares to modularize request processing (middleware dispatcher, chained middlewares, …).
• I know how to find out which middlewares are configured and their order of execution.
• I can write my own middlewares and add them to the frontend and backend request processing.
• I can overwrite Core-provided middlewares.

This skill covers route enhancers which are used to amend the URL routing provided by the TYPO3 core.

• I know what Route Enhancers are and about the different types that the Core provides.

This skill covers custom extensions to the TYPO3 Core Site configuration module.

• I can add custom fields to the site configuration module.
• I know how to read values that are stored in custom site configuration fields.

This skill covers the USER and USER_INT TypoScript objects, which are used to integrate custom code in the TYPO3 frontend rendering process.

• I know what the USER TypoScript object is and how it relates to plugins.
• I know the differences between USER and USER_INT.

This skill covers the JavaScript API for Events in the TYPO3 Backend, relevant for programming custom backend modules and extending existing modules.

• I know about the Event API in JavaScript
• I can register my own event listeners
• I know about the different event strategies and their performance implications
• I know about the different event classes and when to use which of them

The focus of this skill is providing custom events within the TYPO3 PSR-14 implementation.

• I can create events for my custom extensions and dispatch them with the Core’s EventDispatcher.
• I know how to implement the different event use cases specified in PSR-14

This skill covers the implementation and usage of events in the TYPO3 Core.

• I know how the TYPO3 Core defines events and attaches listeners to events.
• I can register my own listeners for events provided by the Core, extensions and 3rd-party PHP libraries.

This skill covers debugging the registration, dispatching and handling of events.

• I know how to retrieve a list of registered event listeners.
• I can use the admin panel to retrieve an overview of dispatched events.

This skill covers the PSR HTTP client standard.

• I know about the client interface provided by PSR-18.

This skill covers the PSR standard for HTTP message factories and the differences to the earlier HTTP request/response standard.

• I know about the various interfaces provided by PSR-17 and their different purposes
• I know why PSR-17 was created and the differences to PSR-7

This skill covers the feature that allows developers to define actions for notifications.

• I know how to add custom javascript actions in notification messages.

The focus of this skill is to know how to utilize notifications for backend users.

• I know how to create notification messages in the TYPO3 backend by using JavaScript.

The abstraction for paginations provided by the TYPO3 Core.

• I know that the Native List Pagination API exists and how and when to use it.
• I am familiar with the Pagination API that can be used to implement paginated lists.
• I know which data types can be paginated.
• I know the commonly used attributes to influence the pagination behavior such as the number of items to be paginated or how many items should be displayed per page.

Modifying CKeditor’s configuration programmatically: You can modify existing or add complete new configurations

• I know how to configure the Rich Text Editor in TYPO3. I know how to modify YAML configuration, programatically, using events.

This skill covers creating custom widgets for the TYPO3 Backend Dashboard and configuring existing widget groups.

• I know which base classes and interfaces the TYPO3 Core provides to build my own custom widgets.
• I know how to register new widgets and how to assign them to one or multiple widget groups.
• I can create new widget groups.

This skill covers the creation of custom Route Enhancers for the TYPO3 frontend routing.

• I know the difference between a Route Enhancer, a Decorator and a Mapper.
• I know how to implement a custom Route Enhancer.
• I can use my custom Route Enhancer for to route requests to my extension

This skill covers the translation configuration of database records via TCA.

• I can make records translatable.
• I know how to configure translation behavior of TCA columns.
• I am familiar with the different translation modes in relation fields (IRRE).

This skill covers different types of dependency injection in TYPO3 and the configuration of dependency injection.

• I can configure my extension to make use of PSR-11 dependency injection.
• I know the different approaches to dependency injection in TYPO3.
• I can decide which classes can be or need to be public.
• I know how to debug problems with dependency injection.

The AssetCollector class, its methods and the corresponding ViewHelpers.

• I can add CSS and JavaScript files to my controllers and views.
• I am aware of the pros and cons of the API and the f:asset.* ViewHelpers, and I know when and how to use one or the other.

The TYPO3 Version information API.

• I know how to retrieve the major and branch version numbers of the current TYPO3 instance.

Classes for data structures, e.g., the BitSet and Enumeration class, and their usage.

• I can decide in which cases to use the BitSet class, can explain the drawbacks and know how to use it properly.
• I understand how bit sets work in general.
• I know the use cases of the Enumeration class and the patterns to use for it.
• I know the use case of the TypeInterface and how to use it.

The lowlevel extension allows examining the current TYPO3 configuration.

• I know which information the backend module of EXT:lowlevel provides.
• I can examine my configuration changes with the help of the EXT:lowlevel backend module.
• I know how to debug execution order of middlewares and event handlers with EXT:lowlevel.
• I know how to utilize the tools that EXT:lowlevel provides for managing my development instance.

Knowing the file structure of an extension and where to place files by convention and due to technical requirements.

• I know how the directory structure of a TYPO3 extension looks like and the additional Extbase conventions.
• I know the purposes of files in TYPO3 extensions (such as ext_emconf.php, ext_tables.php, and others).
• I can create an extension that is installable via the TYPO3 Extension Manager and/or Composer.

Configuring database tables for usage in the backend and frontend.

• I know about the different sections of the TCA (ctrl, columns, palettes, …).
• I know how to configure rendering of a table in backend forms.
• I know how the TCA controls information processing by the TYPO3 core (DataHandler).
• I know how the TCA is compiled from different extensions and cached.
• I can create a compliant TCA for my extensions.
• I can extend the TCA of existing tables from the core or other extensions.

This skill handles definition of own database tables and fields for an extension for automatic management by the TYPO3 Core.

• I can write an ext_tables.sql file both for creating new and extending existing tables.
• I know which fields are generated automatically based on the TCA.

Knowledge about how to access and manipulate data in DBMS.

• I know where to find information about SQL.
• I know how to issue queries against my local setup.

How to build Scheduler tasks for automating recurring tasks.

• I know how to create a new Scheduler task.
• I know about the context Scheduler tasks are executed in.

This skill introduces usage of Composer for extensions and their integration into TYPO3 projects.

• I know which fields to use in the composer.json of my extension, what they mean and how they work, so that I can create working, readable and helpful composer.json files.
• I can use 3rd-party extensions and my own extensions in my site project via Composer.
• I also know the benefits and drawbacks of using Composer and can advise my coworkers and clients when to use which approach.
• In addition, I can build composer.json and ext_emconf.php files in such a way that their data is synchronized correctly.
• Also, I know how to update the autoloader data for non-Composer installations.

This skill covers the TYPO3-specific parts of RequireJS: how this library is used in TYPO3 and how developers can leverage the TYPO3 Core API to use their own JavaScript code in the TYPO3 Backend.

• I can write and use a RequireJS module in the TYPO3 Backend.
• I can change RequireJS configuration to provide new shims for libraries that do not support RequireJS out of the box.

Basic knowledge about how AJAX actions are handled in the TYPO3 Backend and how custom code can be added to be called via AJAX.

• I can register routes for backend AJAX calls.
• I know how to process incoming AJAX requests in PHP.
• I can execute AJAX requests in JavaScript.
   

This skill covers the implementation of update wizards, which can be used by integrators to update existing extension data and configuration after upgrading the extension.

• I can implement an update wizard and know when to use it.

The different PHP autoloading standards (PSR-4, class maps), how they map PHP classes to files and folders, and how the PSR-4 autoloading is configured.

• I know where to place the class file for a certain class in a certain namespace when using PSR-4 autoloading.
• I can set up a proper PSR-4 autoloading configuration.
• I know how to debug and solve problems related to autoloading.

How to make extensions translatable and localizable.

• I know conventions for language file names and file paths in TYPO3. 
• I know the basics of the translation concept of TYPO3. 
• I can translate labels in Fluid (f:translate ViewHelper). 
• I can provide translatable TCA and Flexform labels.

Knowing how to write code conforming to the coding standards used by the TYPO3 project.

• I am familiar with the PSR standard and the usage in TYPO3.
• I know the TYPO3 namespace conventions.
• I know the official TYPO3 coding guidelines for PHP, JavaScript, etc.

The syntax and general purpose of documentation blocks, and the most often used annotations.

• I know how PHPDoc blocks look and I know the general purpose and limitations.
• I can write valid annotations.

Introducing the concept of MVC in Extbase: base classes for models, controllers, repositories; the concept of services and utilities and when to use them.

• I know which kinds of models exist in Extbase.
• I know how a repository for a model is implemented.
• I know how plugins relate to controllers and actions.
• I know how TYPO3/Extbase determines a template for a controller action.
• I can create a new plugin with one or multiple controllers.
• I can define templates for my controller actions.
• I can create a model and the related repository.

Provides the foundations for using custom PHP code in a Fluid-based view.

• I know which base classes for ViewHelpers exist.
• I know which functionality should be placed in a ViewHelper and what is better suited for a controller, service or utility.
• I can create my own ViewHelpers and use them in a template.
• I can register custom ViewHelper arguments.
• I can implement a custom conditional ViewHelper.

How requests are handled by Extbase.

• I know how an Extbase request relates to the TYPO3 page rendering process.
• I know how Extbase namespaces its arguments.
• I know the difference between forwards and redirects.
• I can extract arguments from the request data.
• I can add custom data to a response in my controller actions.

Explaining the view part of MVC in Extbase.

• I know how data is passed to the view.
• I know how a view is configured in a controller.
• I know how different types of views can be used.
• I can pass variables to my template.

This skill covers the use cases and different ways to extend the built-in models of Extbase.

• I know which models are shipped with Extbase by default.
• I know when to use which default model as a base for own models.
• I know how to map database fields to properties.

How Extbase interacts with the permanent storage.

• I know how Extbase works when it stores and retrieves persistent data.
• I know the lifecycle of an object.

The built-in PersistenceManager.

• I am familiar with the PersistenceManager class.
• I know when to use the class to manually trigger I/O operations.
• I know at what point the PersistenceManager is triggered to automatically persist data.

Knowing the default repository class.

• I know which standard and magic query methods are shipped.
• I know which restrictions apply to queries by default.

How to implement custom persistence functionality in Extbase.

• I know how to apply customized query settings to all repository queries.
• I know how to manipulate query settings for a specific method.
• I know the difference between Extbase and Doctrine queries.
• I can create custom queries using the Extbase mechanisms.

What concepts exist to validate controller action input parameters.

• I know about annotations to validate model properties.
• I know which input parameter validation is automatically applied to controller actions.
• I know about annotated validations for controller actions.

How to provide custom validation in Extbase.

• I know which classes I can use to base custom developed validators on.
• I know in which location a custom validator class should be stored by convention and how to register the class.
• I know how to use the validator in a controller action.

How to handle validation errors.

• I know about the built-in error action, how it works and when it is used.
• I know how to provide a custom error action by overriding the default.

This skill covers controllers, the "C" in the MVC pattern.

I know which role controllers play in the pattern.

This skill is about PHPDoc annotations particular to Extbase.

• I can use the correct Extbase annotations in my models and controllers.
• I know which annotation I should use when several possible options are available.

This skill covers the registration of a backend module to make it available to users.

• I can register backend modules based on Extbase.
• I can register backend modules without Extbase.

This skill covers the registration of a frontend plugin to make it available to users.

• I know how to register a plugin with and without Extbase.
• I know how to register a plugin/controller as a content element.
• I know how to declare actions as uncached in Extbase.
• I know how to register a cached or uncached plugin without Extbase.

Knowledge about possible ways to retrieve and process user input.

• I know how to access the arguments and values of a URL.
• I know how to access data passed into the system from forms.
• I know how to retrieve data from third-party systems.
• I know the typical security risks when user input is accessed/processed.

Knowledge about securely processing user input for database queries.

• I know what an SQL injection is.
• I know how to sanitize user input to prevent SQL injections.
• I know what other measures to take against SQL injections.

Knowledge about securely outputting values gained through user input.

• I know what cross-site scripting (XSS) is.
• I know how to prevent user input from triggering XSS.

Knowledge about securely processing user input in PHP code.

• I know about vulnerabilities path traversal, arbitrary code execution and information disclosure.
• I can apply mitigations to prevent these vulnerabilities.

Knowledge about possible vulnerabilities in web development.

• I know what cross-site scripting (XSS) is.
• I know what arbitrary code execution is.
• I know what SQL injection is.
• I know how I can prevent these vulnerabilities in my code.

This skill covers the concept of Prepared Statements in relational databases.

• I know what prepared statements are and what their purpose is
• I know why they improve security and against which attack vectors they protect

Composer basics and its usage for PHP projects.

I know

• what Composer is
• the purpose and the structure of file composer.json
• what composer.lock is and which purpose it serves
• the difference between the install and the update command

I can

• create a new Composer project
• specify requirements for my project
• install packages using Composer
• update packages
• remove packages

Basics and most important commands for working with the version-control system Git.

I know

• what a VCS is
• what a branch is
• what a tag is
• what a repository is
• what a merge is

I can

• initialize a Git repository
• execute commands "commit", "push" and "pull"
• create a branch and work on it
• assign a tag to a certain development state
• merge code