Docstoc

Road-map - Drupal Groups

Document Sample
Road-map - Drupal Groups Powered By Docstoc
					                                                     Road-map




Coaching follow-up
 Name              Drupal learning road map
 Type
 (internship/ self-
 training)          Self-training
 Starting level     Beginner Drupal Developer (Has knowledge about: LAMP, HTML, CSS, JS – Jquery)
 Level to achieve Junior Drupal Developer


                                                                                                          Time
 Road Map          Task                               Goal                                              estimated
                                                                                                          Hours
                                                      - Understand the technologies that drive Drupal
                                                      (PHP, HTML, JS, CSS, Webserver, …)
                   Writing a Module                   - Have overview concept about : Drupal core
                                                      libraries, Drupal hooks, Drupal core modules,
                                                      database & Theme system                              3
                                                      Understand the Drupal concepts about: Themes,
 Drupal overview   Drupal's major subsystems          Menus, Nodes, Files, Users, Comments, Form
                                                      API, Blocks                                          3
                   Drupal source files structure
                                                      Understand source file structure of Drupal core      1
                   Online support document for        Understand where can find the Drupal document:
                   developer                                                                               1
                                                    Understand how to Install process & the
                   Install Drupal Core
                                                    parameters during installing progress                  1
                                                    Understand how to use Drupal Admin to make a
                   Content management system: Node, new Node Type, Fields in Node Type, how to
                   Content Type, Menu, Taxonomy     manage the Menu system, how to use Drupal
                                                    Taxonomy                                               4
 Understanding                                      Understand how to use the Drupal Admin to
                   Blocks & Theme configuration
 Drupal                                             config blocks & themes                                 1
                                                    Understand how to use Drupal Admin to manage
                   Users, roles & permission
                                                    users, roles & permission                              1
                                                    Understand how to use Drupal Admin
                   Writing a Module
                                                    configuration area                                     2
                   Installing contributed themes &  Understand how to install new modules &
                   modules                          themes                                                 1
                                                    The trainee should be able to perform the
                                                    following tasks
                                                    - Create a Drupal module from scratch.
                                                    - Understand how to hook into Drupal’s code
                   Writing a Module                 execution (can implements some basic Drupal
                                                    hook).
                                                    - Create and process simple forms using
                                                    Drupal’s forms API.                                    6
                                                      Page 1
                                                            Road-map




 Real time
                 Reference
  Hours
                 http://drupal.org/getting-started/before/overview
                 http://drupal.org/requirements


             3
                 http://drupal.org/node/19828

             3
               http://programmingexamples.wikidot.com/drupal-file-
             1 structure
               Ex: the API: http://api.drupal.org/
               The coding standard: http://drupal.org/coding-standards
             1 Develop for Drupal guide:
               http://drupal.org/documentation/install
             1
               http://drupal.org/node/627332
               http://drupal.org/node/120632
               http://drupal.org/node/120635
             4 http://drupal.org/node/120624
               http://drupal.org/node/120634
             1
               http://drupal.org/node/120614
             1 http://drupal.org/node/627158

             2
               http://drupal.org/documentation/install/modules-
             1 themes/modules-7
               http://drupal.org/node/361112
               http://drupal.org/project/examples
               http://api.drupal.org

6
Need to deep
knowledge
about hook
                                                             Page 2
                                        Road-map
                                         The trainee should be able to
                                         - Map URLs to functions in your module or other
                                         modules or .inc files.
                                         - Understand how access control works.
               The Menu System           - Understand how wildcards work in paths.
                                         - Create pages with tabs (local tasks) that map to
                                         functions.
                                         - Modify existing menu items and links
                                         programmatically.                                    4
                                         The trainee you should be able to
                                         Basic Theming:
                                         - Create template files.
                                         - Override theme functions.
               The Theme System          - Manipulate template variables.
                                         - Create new page regions for blocks.
                                         Advance Theming
                                         - Understand Starter Themes
                                         - Can use some famous Starter: ex Omega              8

                                         The trainee you should be able to
                                         - Understand Drupal’s database abstraction
                                         layer.
                                         - Perform basic queries.
                                         - Get single and multiple results from the
               Working with Databases    database.
                                         - Get a limited range of results.
                                         - Use the pager.
                                         - Understand Drupal’s schema API.
                                         - Write queries so other developers can modify
                                         them.
                                         - Cleanly modify the queries from other modules.     4




Basic Drupal
development




                                         Page 3
                                                      Road-map
            http://api.drupal.org/api/drupal/includes--
            menu.inc/group/menu/7
            http://drupal.org/documentation/modules/menu
            http://drupal.org/project/examples : : menu_example




        4
            http://drupal.org/documentation/themehttp://drupal.org/
            node/323993http://drupal.org/project/omega




Later
            http://drupal.org/developing/api/database
            http://api.drupal.org/api/drupal/includes--
            pager.inc/7#comment-14299
            http://drupal.org/project/examples : : dbtng_example




        4




                                                       Page 4
                                             Road-map




                                              The trainee should understand the following
                                              concepts:
                                              - How the form API works.
                                              - Creating simple forms.
                                              - Changing the rendered form using theme
                                              functions.
Basic Drupal                                  - Writing a validation function for a form or for
development                                   individual elements.
               The Form API                   - Writing a submit function and doing redirection
                                              after form processing.
                                              - Altering existing forms.
                                              - Creating dynamic forms.
                                              - Using the #ajax property to create dynamic
                                              forms that react to users input without page
                                              reloads
                                              - The form definition properties you can use and
                                              what they mean.
                                              - The form elements (text fields, select fields,
                                              radios, and so on) thatre available inDrupal.
                                              - How AJ-based text replacement works with
                                              forms.                                              8
                                              The trainee should understand the following
                                              concepts:
               Working with Blocks            - How to define a block
                                              - How block visibility and placement settings
                                              work.                                               4
                                              The trainee should understand the following
                                              concepts:
                                              - Understand how users are represented
                                              internally in Drupal.
               Working with Users
                                              - Hook into the user login process, register
                                              process, edit user information process
                                              - Understand how external user authentication
                                              works.                                              4
                                              The trainee should understand the following
                                              concepts:
                                              - Understand what a node is and what node
                                              types are.
               Working with Nodes & Fields    - Understand how to hook into node creation,
                                              saving, loading, and so on.
                                              - Understand how access to nodes is
                                              determined.
                                              - Understand how to create a custom field type      8

                                              The trainee should understand the following
                                              concepts:
               Working with Files
                                              - Build a module to use for image, video, and
                                              audio handling.
                                              - Common functions for manipulating files.          4



                                              Page 5
                                                           Road-map
                http://drupal.org/node/37775
                http://api.drupal.org/api/drupal/developer--topics--
                forms_api_reference.html
                http://api.drupal.org/api/drupal/includes--
                form.inc/group/form_api/7
                http://drupal.org/project/examples : : form_example,
                ajax_example
                http://drupal.org/node/165104




Need some
help
                http://drupal.org/documentation/modules/block
                http://drupal.org/project/examples : : block_example



                http://drupal.org/node/628280




                http://drupal.org/documentation/modules/field-ui
                http://drupal.org/project/examples: : node_example,
                nodeapi_example, node_access_example,
                field_example




            8
                http://api.drupal.org/api/drupal/includes--
                file.inc/group/file/7
                http://drupal.org/node/627244
                http://drupal.org/node/555118
                http://drupal.org/project/examples: : file_example,
                image_example



                                                            Page 6
                                                Road-map
                                                 The trainee should understand the following
                                                 concepts:
                                                 - How to add internal javascript code and extenal
                                                 javascript file
                 Using Javascript in Drupal
                                                 - How jQuery and Drupal interact to pass
                                                 requests and data back and forth.
                                                 - Understanding Drupal javascript library
                                                 (/misc/drupal.js)                                   4
                                                 The trainee should understand the following
                                                 concepts:
                                                 - Understand how to assign actions to triggers.
                 Actions, and Triggers           - Write a simple action.
                                                 - Define your own hooks and have them
                                                 displayed as triggers.                              4
                                                 The trainee should understand the following
                                                 concepts:
                                                 - Understand what taxonomy is.
                                                 - Understand terms, vocabularies, and their
                 Working with Taxonomy
                                                 different options.
                                                 - Viewing Content by Term.
                                                 - Know how to use vocabularies within your own
                                                 module.                                             4
                                                 The trainee should understand the following
                                                 concepts:
                                                 - How the t() function works.
                                                 - What portable object (file .PO) and portable
                 Localization and Translation    object template (file .POT) files are.
                                                 - How to download portable object template files
                                                 and generate your own.
                                                 - How to import an existing Drupal translation.
                                                 - How content translation works.                    4
                                                 The trainee should understand the following
Advance Drupal
                                                 concepts:
development                                      - Understand what a filter and a Text format are
                                                 and how they are used to transform text.
                 The Filter System               - Understand why the filter system is more
                                                 efficient than performing text manipulations in
                                                 other hooks..
                                                 - Create a custom filter (how to implements
                                                 hook_filter_info).                                  4

                                                 The trainee should understand the following
                                                 concepts:
                                                 - The various types of caching Drupal provides:
                                                 page, block, menu, variable, and filter caching.
                 Caching                         - How the page-caching systems work & block-
                                                 caching system works.
                                                 - The cache API functions.
                                                 Advance topic (Optional)
                                                 - How to use memcached, opcode cache (APC,
                                                 xCache...) with the CacheRouter module              4




                                                 Page 7
                                           Road-map
http://drupal.org/node/756722
http://drupal.org/project/examples: : js_example




http://drupal.org/node/206811
http://drupal.org/project/examples: : action_example,
trigger_example



http://drupal.org/documentation/modules/taxonomy




http://drupal.org/node/303984
http://drupal.org/node/322729
http://drupal.org/node/324602




http://drupal.org/project/examples: : filter_example




http://drupal.org/node/145279
http://drupal.org/project/cacherouter




                                             Page 8
                                                  Road-map
                                                   The trainee should understand the following
                                                   concepts:
                                                   - Customize the search form.
                 Searching and Indexing Content
                                                   - Understand how to use the search hook.
                                                   - Understand how the HTML indexer works.
                                                   - Hook into the indexer for any kind of content.   8
Development
Best Practices
(Optional)                                                                                            4
                                                   Total                                                  104




                                                   Page 9
                                        Road-map
http://drupal.org/documentation/modules/search
http://drupal.org/node/228411




http://drupal.org/best-practices




                                         Page 10

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:39
posted:8/20/2012
language:English
pages:10