Know about ASP.NET

ASP.NET is an open-source server-side web request framework designed for web progress to manufacture active web pages. It was developed by Microsoft to allow programmers to construct dynamic web sites, web applications and web services. It was first at large in January 2002 with 

version 1.0 of the .NET Framework, and is the descendant to Microsoft's Active Server Pages (ASP) technology. ASP.NET is built on the Common Language Runtime (CLR), allow programmers to put pen to paper ASP.NET code by means of every supported .NET language. The ASP.NET SOAP addition framework allows ASP.NET components to process SOAP messages. ASP.NET's successor is ASP.NET Core. It is a re-implementation of ASP.NET as a modular web framework, together with other frameworks like Entity Framework. The latest framework uses the new open-source .NET Compiler Platform (codename "Roslyn") and is cross platform. ASP.NET MVC, ASP.NET Web API, and ASP.NET Web Pages (a platform using only Razor pages) have complex into a unified MVC 6.

Behind four years of development, and a series of beta releases in 2000 and 2001, ASP.NET 1.0 was released on January 5, 2002 as division of version 1.0 of the .NET Framework. Even prior to the free, dozens of books had been written about ASP.NET, and Microsoft promoted it a lot as part of its platform for Web services. Scott Guthrie became the produce unit manager for ASP.NET and development constant apace, with version 1.1 being released on April 24, 2003 as a part of Windows Server 2003. ASP.NET is anxiously based on HTML. This free focused on improving ASP.NET's maintain for mobile devices. ASP.NET Web pages, recognized formally as Web Forms, are the main building blocks for application development in ASP.NET. There are two essential methodologies for Web Forms, a web application arrangement and a web site format. Web applications need to be compiled before deployment, while web sites structures permit the user to copy the files straight to the server without previous collection. Web forms are controlled in files with a ".aspx" extension;

 

 these files classically contain static (X)HTML markup or constituent markup. The constituent markup can include server-side Web Controls and User Controls that have been definite in the framework or the web page. For example, a textbox component can be defined on a page as <asp:textbox id='myid' runat='server'>, which is rendered into a html contribution box. Moreover, dynamic code, which runs on the server, can be placed in a page within a block <% -- dynamic code -- %>, which is alike to other Web development technologies such as PHP, JSP, and ASP. With ASP.NET Framework 2.0, Microsoft introduced a latest code-behind model that lets inert text stay on the .aspx page, while active code remains in an .aspx.vb or .aspx.cs or .aspx.fs file (depending on the programming language used). Microsoft recommends commerce with active program code by using the code-behind mock-up, which seats this code in a divide file or in a particularly designated script tag. Code-behind files classically have names like MyPage.aspx.cs or MyPage.aspx.vb while the page file is MyPage.aspx (same filename as the page file (ASPX), but with the final extension denoting the page language). This carry out is automatic in Visual Studio and other IDEs on the other hand the user can modify the code-behind page. Also, in the web application format, the pagename.aspx.cs is a incomplete class that is linked to the pagename.designer.cs file. The designer file is a file that is auto generated from the aspx page that allows the programmer to position workings in the aspx page from the cs page without having to announce them physically as in versions prior to ASP.Net version 2. When using this style of programming, the developer writes code to counter to dissimilar events, like the page being loaded, or a manage being clicked, rather than a technical walkthrough of the document. ASP.NET's code-behind model marks a going away from Classic ASP in that it encourages developers to construct applications with division of arrangement and satisfied in mind. In theory, this would allow a Web designer, for example, to focus on the design markup with less potential for disturbing the programming code that drives it. This is similar to the separation of the controller from the view in model–view–organizer (MVC) frameworks. .NET uses a "visited composites" depiction method. During collection, the template (.aspx) file is compiled into initialization code that builds a control tree (the composite) in lieu of the unique template. Literal text 

goes into instance of the Literal organize class, and server controls are represented by instances of a explicit control class. The initialization code is collective with user-written code (usually by the assembly of numerous partial classes) and consequences in a class definite for the page. The page doubles as the root of the manage tree. Genuine requirements for the page are processed through a number of steps. First, during the initialization steps, an example of the page class is shaped and the initialization code is executed. This produces the initial manage tree, which is now classically manipulated by the systems of the page in the next steps. As every node in the tree is a manage represented as an example of a class, the code may modify the tree arrangement as well as control the properties/methods of the person nodes. Finally, through the depiction step a visitor is used to visit each node in the tree, asking every node to turn into it using the methods of the visitor. The resulting HTML production is sent to the consumer. After the request has been processed, the example of the page class is surplus and with it the entire control tree. This is a basis of confusion amongst novice ASP.NET programmers who rely on the class instance members that are mislaid with every page demand/response cycle. ASP.NET applications are hosted by a Web server and are accessed by means of the stateless  HTTP protocol. As such, if an application uses stateful interaction, it has to apply state organization on it’s possess. ASP.NET provides a variety of functions for state management. Theoretically, Microsoft treats "state" as GUI state. Problems may arise if an application must track "data state"; for instance, a finite-state engine that may be in a fleeting state between requirements (lazy evaluation) or takes a long time to initialize. State organization in ASP.NET pages with confirmation can make Web scraping hard or unfeasible. Application state is held by a compilation of shared user-defined variables. These are set and initialized when the Application_OnStart happening fires on the loading of the first example of the application and are available until the last example exits. Application state variables are accessed using the Applications collection, which provides a wrapper for the application situation. Application condition variables are identified by name. 

Application is state organization. Server-side assembly state is detained by a collection of user-defined assembly variables that are persistent throughout a user meeting. These variables, accessed using the Session compilation, are exclusive to each session occurrence. The variables can be set to be robotically destroyed after a distinct time of idleness even if the session does not finish. Client-side user session is maintained by neither a cookie nor by encoding the session ID in the URL itself.  ASP.NET supports three modes of persistence for server-side session variables:  The session variables are maintained inside the ASP.NET method. This is the best way; though, in this mode the variables are shattered when the ASP.NET method is recycled or shut down. ASP.NET runs a divide Windows service that maintains the situation variables. Because state organization happens exterior the ASP.NET process, and because the ASP.NET engine accesses data using .NET Remoting, ASPState is slower than In-System. This mode permits an ASP.NET application to be load-balanced and scaled crosswise manifold servers. Because the state organization service runs separately of ASP.NET, the session variables can keep it up across ASP.NET method shutdowns. Though, since session state server runs as one instance, it is still one point of crash for session state. The session-state service cannot be load-balanced, and there are limitations on types that can be stored in a session variable.

State variables are stored in a database, allowing assembly variables to be persisted crosswise ASP.NET method shutdowns. The major benefit of this mode is that it allows the application to balance load on a server cluster, sharing sessions between servers. This is the slowest system of session state management in ASP.NET. ASP.NET session state enables you to accumulate and get back values for a user as the user navigates ASP.NET pages in a Web application. HTTP is a stateless procedure. This means that a Web server treats every HTTP request for a page as a free request. The server retains no information of variable values that were used throughout earlier requests. ASP.NET session state identifies requests from the similar browser during a partial time window as a session, and provides a way to continue variable values for the period of that session. By default, ASP.NET session state is enabled for all ASP.NET applications. Application state, which provisions variables that can be accessed by everyone users of an ASP.NET application. Profile properties, which persists user values in a data amass with no dying them. ASP.NET caching, which stores values in memory that is obtainable to all ASP.NET applications. View state refers to the page-level state organization mechanism, utilized by the HTML pages emitted by ASP.NET applications to uphold the state of the 

 

Web form reins and widgets. The state of the reins is encoded and sent to the server at each form obedience in a concealed field known as __VIEWSTATE. The server sends reverse the variable so that, when the page is re-rendered, the controls cause to be at their last state. At the server side, the application may alter the view state, if the dispensation requires alter of state of any manage. The states of person controls are decoded at the server, and are obtainable for use in ASP.NET pages using the View State collection. The major use for this is to protect form information crosswise postbacks. View state is curved on by defaulting and usually serializes the data in each manage on the page in spite of whether it is in fact used during a postback. This behavior can be customized, though, as View state can be disabled on a per-control, per-page, or server-wide basis. Developers require being cautious of storing sensitive or confidential information in the View state of a page or control, as the base64 string containing the view state data can with no trouble be de-serialized. By defaulting, View state does not encrypt the __VIEWSTATE value. Encryption can be enabled on a server-wide (and server-specific) foundation, allowing for a sure level of security to be maintained. ASP.NET offers a "Cache" object that is common crosswise the application and can also be used to store different objects. The "Cache" object holds the data merely for a specific amount of time and is mechanically cleaned after the session time-limit elapses. Other resources of state organization that are supported by ASP.NET are cookies, caching, and using the query string.

PHP Introduction

The following ‘Hi, what’s up?’ program is in black and white in PHP code set in an HTML document: <!DOCTYPE html><html> <head><title>PHP</title></head> <body> <?php echo “<p> Hi, what’s up?</p>”; ?> </body></html> However, as no condition exists for PHP code to be implanted in HTML, the simplest version of Hello, World! may be printed like this, with the closing tag absent as favorite in files

containing pure PHP code <?='Hello world'; The PHP prophet only executes PHP code within its delimiters. Anything outside its delimiters is not processed by PHP, though non-PHP text is still subject to manage structures described in PHP code. The most common delimiters are <?php to open and ?> to close PHP sections. The shortened form <? Also exists. This short delimiter makes script files less portable, since bear for them can be disabled in the local PHP intend and it is therefore downcast. However, there is no proposal against the use of the echo short tag <?=.Prior to PHP 5.4.0, this short syntax for echo() only works with the short_open_tag pattern set enabled, while for PHP 5.4.0 and later it is always obtainable. The idea of all these delimiters is to separate PHP code from non-PHP content, for example JavaScript code or HTML markup. The first form of delimiters, <?php and ?>, in XHTML and other XML documents, creates properly formed XML processing directives. This means that the ensuing mixture of PHP code and other markup in the server-side file is itself well-formed XML. Variables are prefixed with a dollar figure, and a type does not need to be particular in advance. PHP 5 introduced type hinting that allows functions to force their parameters to be objects of a explicit class, arrays, interfaces or callback functions. However, before PHP 7.0, type hints could not be used with scalar types such as integer or string. Unlike function and class names, variable names are case sensitive. Both double-quoted ("") and heredoc strings afford the ability to interpolate a variable's value into the string. PHP treats newlines as whitespace in the approach of a free-form language, and statements are finished by a semicolon. PHP has three types of comment syntax: /* */ script block and inline comments; // as well as # are used for one-line comments. The echo account is one of numerous facilities PHP provides to output text, e.g., to a web browser. In terms of keywords and words syntax, PHP is similar to the C style syntax. if conditions, for and while loops, and function returns are alike in syntax to languages such as C, C++, C#, Java and Perl. The following is an example of PHP for loop:<?php for ($x = 0; $x <= 100; $x++) {echo "The number is: $x <br>";} ?> Data types PHP stores integers in a platform-dependent variety, either a 64-bit or 32-bit signed integer equal to the C-language long type. Unsigned integers are changed to signed values in certain situations; this manner is diverse from that of other encoding languages. Integer variables can be assigned using decimal (positive and negative), octal,

hexadecimal, and double notations. Floating point numbers are also stored in a platform-specific range. They can be specified using floating point notation, or two forms of scientific notation. PHP has a native Boolean type that is similar to the native Boolean types in Java and C++. Using the Boolean type conversion rules, non-zero values are interpreted as true and zero as false, as in Perl and C++. The null data type represents a variable that has no value; NULL is the only allowed value for this data type. Variables of the "resource" type signify references to resources from outside sources. These are typically fashioned by functions from a meticulous addition, and can only be processed by functions from the same extension; examples include file, image, and database wealth. Arrays can contain elements of any type that PHP can handle, including income, objects, and other arrays. Order is conserved in lists of values and in hashes with both keys and values, and the two can be intermingled. PHP also chains strings, which can be used with single quotes, double quotes, nowdoc or heredoc syntax. The Standard PHP Library (SPL) attempts to solve standard problems and implements competent data access interfaces and classes.

Functions

PHP defines a great array of functions in the core language and many also exist in various extensions; these functions are well documented in the online PHP documentation. However, the built-in library has a wide variety of naming conventions and allied inconsistencies, as described under history above. Custom functions may be defined by the developer, e.g.:

function myAge($birthYear) {                                  // defines a function, this one is named "myAge"

    $yearsOld = date('Y') - $birthYear;                       // calculates the age

    return $yearsOld . ' year' . ($yearsOld != 1 ? 's' : ''); // returns the age in a descriptive form

}

echo 'I am currently ' . myAge(1981) . ' old.';               // outputs the text concatenated

                                                              // with the return value of myAge()

// As the result of this syntax, myAge() is called. In 2017, the output of the above sample program is 'I am currently 36 years old.' In lieu of function pointers, functions in PHP can be referenced by a string containing their name. In this manner, normal PHP functions can be used, for example, as callbacks or within function tables. User-defined functions may be formed at any time without being prototyped. Functions may be distinct inside code blocks, permitting a run-time decision as to whether or not a function should be defined. There is a function exists function that determines whether a function with a given name has previously been defined. Function calls must use parentheses, with the exception of zero-argument class constructor functions called with the PHP operator new, in which case parentheses are optional. Until PHP 5.3, support for anonymous functions and closures did not exist in PHP. While create_function() exists since PHP 4.0.1, it is merely a thin wrapper around eval() that allows ordinary PHP functions to be created throughout program execution. PHP 5.3 added syntax to define an anonymous function or "closure" which can capture variables from the surrounding scope:

function getAdder($x) {

    return function($y) use ($x) {

        return $x + $y;

    };

}

$adder = getAdder(8);

echo $adder(2); // prints "10"

In the example above, getAdder() function creates a closure using conceded argument $x (the keyword use imports a variable from the lexical context), which takes an additional argument $y, and returns the created closure to the caller. Such a function is a first-class object, meaning that it can be stored in a variable, passed as a parameter to other functions, etc.  Unusually for a dynamically typed language, PHP supports type declarations on function parameters, which are enforced at runtime. This has been supported for classes and interfaces since PHP 5.0, for arrays since PHP 5.1, for "callables" since PHP 5.4, and scalar (integer, float, string and boolean) types since PHP 7.0. PHP 7.0 also has type declarations for function return types, expressed by placing the type name after the list of parameters, preceded by a colon. For example, the getAdder function from the earlier example could be annotated with types like so in PHP 7: function getAdder(int $x): \Closure { return function(int $y) use ($x) : int { return $x + $y; }; }$adder = getAdder(8); echo $adder(2);        // prints "10" echo $adder(null);     // throws an exception because an incorrect type was passed $adder = getAdder([]); // would also throw an exception By default, scalar type declarations follow weak typing principles. So, for example, if a parameter's type is int, PHP would allow not only integers, but also convertible numeric strings, floats or booleans to be passed to that function, and would convert them. However, PHP 7 has a "strict typing" mode which, when used, disallows such conversions for function calls and returns within a file.  Object-oriented programming Basic object-oriented programming

functionality was added in PHP 3 and improved in PHP 4. This allowed for PHP to gain further abstraction, making creative tasks easier for programmers using the language. Object handling was completely rewritten for PHP 5, expanding the feature set and enhancing performance. In previous versions of PHP, objects were handled like value types. The drawback of this method was that code had to make heavy use of PHP's "reference" variables if it wanted to modify an object it was passed rather than creating a copy of it. In the new approach, objects are referenced by handle, and not by value. PHP 5 introduced private and protected member variables and methods, along with abstract classes, final classes, abstract methods, and final methods. It also introduced a standard way of declaring constructors and destructors, similar to that of other object-oriented languages such as C++, and a standard exception handling model. Furthermore, PHP 5 added interfaces and allowed for multiple interfaces to be implemented. There are special interfaces that allow objects to interact with the runtime system. Objects implementing ArrayAccess can be used with array syntax and objects implementing Iterator or IteratorAggregate can be used with the foreach language construct. There is no virtual table feature in the engine, so static variables are bound with a name instead of a reference at compile time.

Know about JQuery & Joomla

jQuery is a cross-platform JavaScript library designed to make things easier the client-side scripting of HTML  JQuery is the most well-liked JavaScript library in use today, with installation on 65% of the top 10 million highest-trafficked sites on the Web.  JQuery is at no cost, open-source software qualified below the MIT License.   JQuery’s syntax is designed to make it easier to map read a document, select DOM elements, generate animations, handle events,

 and develop Ajax applications. JQuery also provides capabilities for developers to generate plug-ins on top of the JavaScript library. This enables developers to create abstractions for low-level contact and animation, superior effects and high-level, theme able widgets. The modular come up to to the jQuery library allows the conception of powerful dynamic web pages and Web applications. The set of jQuery core features—DOM element selections, traversal and exploitation—enabled by its selector locomotive (named "Sizzle" from v1.3), fashioned a new "programming style", fusing algorithms and DOM data structures. This

style fractional the architecture of other JavaScript frameworks likes YUI v3 and Dojo, later motivating the conception of the regular Selectors API. Microsoft and Nokia anthology jQuery on their platforms. Microsoft includes it with design Studio for use within Microsoft's ASP.NET AJAX and ASP.NET  MVC

frameworks while Nokia has incorporated it into the Web Run-Time widget expansion platform. jQuery has also been used in Media Wiki since version 1.16.  Contents: Overview, History, Features , Browser ,support, Usage ,Including the library, Usage styles, No-conflict mode ,Typical start-point, Creating new ,DOM elements, Chaining, Utility functions, Ajax , Asynchronous, jQuery plug-ins , Release history, Testing framework,  See also, References, Further reading, External links. JQuery, at its core, is a DOM (Document Object Model) handling library. The DOM is a tree-structure image of all the elements of a Web page. jQuery simplifies the syntax for judgment, selecting, and manipulate these DOM elements. For example, jQuery can be used for finding an element in the document with a convinced property (e.g. all elements with an h1 tag), changing one or more of its attribute (e.g. color, visibility), or making it respond to an event (e.g. a mouse click). JQuery also provides a paradigm for event handling that goes absent from basic DOM element selection and treatment. The event assignment and the event callback meaning description are done in a single footstep in a single location in the code. JQuery also aims to add in other highly used JavaScript functionality (e.g. fade INS and fade outs when hiding elements, animations by manipulating CSS properties). Separation of JavaScript and HTML: The jQuery library provides straightforward syntax for addition event handlers to the DOM using JavaScript, rather than addition HTML event attributes to call JavaScript functions. Thus, it encourages developers to completely divide JavaScript code from HTML markup. Brevity and clarity: jQuery promotes briefness and clarity with facial appearance like chainable functions and shorthand function names. Elimination of cross-browser incompatibilities: The JavaScript engines of diverse browsers differ to some extent so JavaScript code that works for one browser may not work for another. Like other JavaScript toolkits, jQuery handles all these cross-browser inconsistencies and provides a consistent interface that works crosswise dissimilar browsers. Extensibility: fresh events, elements, and methods can be with no trouble additional and then reused as a plug-in. 

JQuery was originally free in January 2006 at Bar Camp NYC by John Resig and was unfair by Dean Edwards' previous cssQuery library.  It is at present maintained by a team of developers led by Timmy Willison (with the jQuery selector locomotive, Sizzle, being led by Richard Gibson). JQuery has also an attractive software license history. Originally below the CC BY-SA 2.5, it was relicensed to the MIT license in 2006. On end of 2006 it was dual-licensed under GPL and MIT license.  As this led to some perplexity, in 2012 the GPL was dropped and is now only MIT licensed.  As of 2015, jQuery leftovers the most extensively used JavaScript library on the Web.  Features DOM element selections using the multi-browser unlock source selector engine Sizzle, a spin-off of the jQuery project DOM handling based on CSS selectors that uses elements' names and attributes, such as id and class, as criteria to choose nodes in the DOM. Deferred and assure objects to organize asynchronous meting out. Utilities, such as characteristic recognition, Compatibility methods that are natively available in modern browsers, but need fall backs for older ones, such as inArray() and each(), Multi-browser (not to be perplexed with cross-browser) sustain. Both versions 1.x and 2.x of jQuery support "current-1 versions" (meaning the existing stable version of the browser and the version that preceded it) of Firefox, Chrome, Safari, and Opera. Version 1.x also handcuffs Internet Explorer 6 or higher. However, jQuery version 2.x dropped Internet Explorer 6–8 carry and supports only IE 9 and afterward versions. The jQuery library is an only JavaScript file containing all of its ordinary DOM, event, effects, and Ajax functions. It can be incorporated within a Web page by linking to a local copy or to one of the many copies accessible from public servers. jQuery has a content liberation network (CDN) hosted by MaxCDN.  Google and Microsoft congregation it as fine. <script src="jquery.js"></script> It is also probable to comprise jQuery straight from a CDN: <script src="https://code.jquery.com/jquery-3.1.0.min.js"></script> Via the $ function, which is a factory method for the jQuery object. These functions, often called instructions, are chainable as they all come back jQuery objects. Via $.-prefixed functions. These are helpfulness functions, which do not act upon the jQuery object straight. Admission to and exploitation of numerous DOM nodes in jQuery naturally begins with calling the $ function with a CSS selector string. This precedes a jQuery object referencing all the matching elements in the HTML page. $("div.test"), for example, precedes a jQuery object with all the div elements of class test. This node set can be manipulated by calling methods on the returned jQuery object or on the nodes themselves. JQuery also includes .no Conflict () mode, which relinquishes control of $. This is helpful if jQuery is used with other libraries that also use $ as an identifier. In no-conflict mode, developers can use jQuery as a substitution for $ with no trailing functionality.  Typically, jQuery is use by putting initialization code and event conduct functions in $(handler). This is triggered when the browser has constructed the DOM and sends a load occasion. $(function () {  // jQuery code, event handling callbacks here }); Historically, $(document).ready(callback) has been the de facto signature for administration code when the DOM is ready. However, since jQuery 3.0, developers are optimistic to use the much shorter $(handler) autograph.   Callback functions for event management on elements that aren't loaded yet can be registered inside .ready () as anonymous functions. These event handlers will only be called when the happening is triggered. For example, the next code adds an event trainer for a mouse click on an img image element. $(function () {   $('img').on ('click', function () {// handle the click event on any img element in the pag   }); }); The next syntaxes are equivalent, though only $(handler) should be used:   This line finds the combination of all div tags with class characteristic test and all p tags with class characteristic quote, adds the class characteristic blue to each matched element, and then increases their height with an moving picture. The $ and add functions influence the matched set, while the add Class and slide Down influence the referenced nodes. Convinced jQuery functions come back specific values (such as $('#input-user-email').val()). In these cases, chaining will not work as the value does not circumstances the jQuery object. Besides accessing DOM nodes from side to side jQuery object pecking order, it is also probable to generate new DOM elements, if a string accepted as the argument to $() looks like HTML. For example, this line finds an HTML select element with ID carmakes, and adds an option element with price "VAG" and text "Volkswagen":

Functions prefixed with $. Are utility functions or functions that influence universal properties and behavior. The following, for example, is a function used for iterating over arrays called every in jQuery: Note that the above example uses the delayed nature of $.ajax() to lever its asynchronous nature: .done() and .fail() generate callbacks that run only when the asynchronous practice is total. jQuery's building allows developers to make plug-in code to expand its function. There are thousands of jQuery plug-ins available on the Web  that wrap a range of functions, such as Ajax helpers, Web services, data grids, dynamic lists, XML and XSLT tools, drag and drop, events, cookie behavior, and modal windows. A significant basis of jQuery plug-ins is the plug-in sub domain of the jQuery Project website.   The plug-in in this sub domain, however, were by chance deleted in December 2011 in an attempt to rid the site of spam.  The new site will include a GitHub-hosted repository, which will necessitate developers to resubmit their plug-in and to conform to new submission requirements.  There are alternative plug-in search engines  like jquer.in that take more specialized approaches, such as catalog only plug-ins that meet certain criteria (e.g. those that have a public code repository). JQuery provides a "Learning Center" that can help users understand JavaScript and get ongoing developing jQuery plugins.

Joomla is a free of charge and open-source content management system (CMS) for publishing web content. It is built on a model–view–controller web application framework that can be used independently of the CMS. Joomla is written in PHP, uses object-oriented programming (OOP) techniques (since version 1.5 and software design patterns,  stores data in a MySQL, MS SQL (since version 2.5), or PostgreSQL (since version 3.0) database,  and includes features such as page caching, RSS feeds, printable versions of pages, news flashes, blogs, search, and bear for language internationalization. As of November 2016, Joomla! Has been downloaded over 78 million times. Over 7,800 complimentary and commercial extensions are available from the official Joomla! Extension Directory and more are available from other sources.  It is estimated to be the second most used content management system on the Internet, after Word Press. Joomla was the effect of a fork of Mambo on August 17, 2005. At that time, the Mambo name was a brand of Miro International Pvt. Ltd, who shaped a non-profit foundation with the stated reason of funding the project and defensive it from lawsuits. The Joomla development team claimed that many of the necessities of the foundation organization violated previous agreements made by the elected Mambo Steering Committee, lacked the essential discussion with key stakeholders and included provisions that violated core open source values.  Joomla developers shaped a website called OpenSourceMatters.org (OSM) to hand out information to the software the public. Project leader Andrew Eddie wrote a letter that appeared on the announcements section of the public forum at mamboserver.com. Over one thousand people joined OpenSourceMatters.org within a day, most redeployment words of encouragement and support. The website received the Slashdot effect as a result. Miro CEO Peter Lamont responded publicly to the development team in an article titled "The Mambo Open Source Controversy — 20 Questions With Miro". This event fashioned disagreement within the free software community about the definition of open source. Forums of other open-source projects were energetic with postings about the proceedings of both sides. In the two weeks following Eddie's statement, teams were re-organized and the community sustained to grow. Eben Moglen and the Software Freedom Law Center (SFLC) assisted the Joomla core team beginning in August 2005, as indicated by Moglen's blog entry from that date and a related OSM announcement.  The SFLC continue to provide lawful direction to the Joomla project.   On August 18, Andrew Eddie called for community effort to put forward a name for the project. The core team held in reserve the right for the last naming finish, and chose a name not compulsory by the community. On September 22, the new name, Joomla!, was announced. It is the anglicised spelling of the Swahili word jumla, meaning all jointly or as a entire which also has a similar meaning in at least Amharic, Arabic and Urdu. On September 26, the expansion team called for logo submissions from the community and invited the community to vote on the logo; the team announced the community's decision on September 29. On October 2, brand guidelines, a make manual, and a set of logo capital were available. Similar to many other web applications, Joomla may be jog on a LAMP stack.  Many web hosts have control panels for habitual installation of Joomla. On Windows, Joomla can be installed by means of the Microsoft Web Platform Installer, which routinely detects and installs dependencies, such as PHP or 

MySQL.  Many web sites provide in sequence on installing and maintaining Joomla sites. Joomla! Utilises a configuration file (configuration.php, typically located in the root of the Joomla! installation) to control a range of settings including (but not limited to) database association settings. Due to the use of a configuration file, migrating from one server to another is relatively simple.  There are two great Joomla conferences each year. Joomla and Beyond (JaB) which is a meeting largely aimed at Joomla Developers and site integrators and is hosted in Europe around May every year. The Joomla World Conference which brings together developers, designers, site administrators, business owners, and community members is held in the latter half of the year. Every year Joomla communities hold their own country or local Joomla Days. Joomla also, like many coding communities hosts many district user groups as well. Extensions Joomla extensions make bigger the functionality of Joomla websites. Eight types of extensions may be illustrious: components, modules,plug in, templates, languages, libraries, files and packages.  Every of these extensions handle a specific function. Many of the extensions built by the Joomla! Community is not without charge but need a payment for download. Components are the main and most multifaceted extensions. Most machinery has two parts: a site part and an administrator part. Every time a Joomla page loads, one component is called to cause to be the main page body. Components produce the major piece of a page because a component is driven by a menu thing. Plug-in are superior extensions and are, in essence, event handlers. In the execution of any part of Joomla, a module or a component, an event may be triggered. When an event is triggered, plug-in that is registered to handle that event carry out. For instance, a plug-in could be used to block user-submitted 

articles and filter text. The line between plug-in and machinery can now and then be a little fuzzy. Sometimes large or advanced plug-in are called components even though they don't actually render large portions of a page. An SEF URL addition might be created as a constituent; even although its functionality could be skillful with just plug-in. Templates explain the main design of a Joomla website. While the CMS manages the website content, templates decide the style or look and suffer and layout of a site.  Modules are active or static output in a template position. Templates define dynamic positions that can be assigned modules. An example could be a boxed login shape in a sidebar. This could be compared to another CMS's "widgets in sidebar". Multiple modules can be assigned to each position and every module's assignment can be proscribed per menu item. Historically, modules are assigned to sidebars around the main component productivity. Languages are very easy extensions that can either be used as a core part or as an addition. Language and font in sequence can also be old for PDF or PSD to Joomla conversions.

Introduction CSS

Cascading Style Sheets (CSS) is a style sheet words used for unfolding the presentation of a document  CSS is 

written in a markup language. Although most often used to set the illustration style of web pages and

designed primarily to enable the screen of document content from document presentation, as well as aspects  CSS has a simple syntax and uses a number of English keywords to detail the names of various style properties. A style sheet consists of a list of rules. Each rule or rule-set consists of one or more selectors, and a declaration block. In CSS, selectors declare which part of the markup a style applies to by similar tags and attributes in the markup itself. All elements of a specific type, e.g. the second-level headers h2 Elements specified by attribute, in particular:  id: an identifier unique within the document class: an identifier that can annotate numerous elements in document elements depending on how they are placed relation to others in the document tree. Classes and IDs are case-sensitive, start with letters, and can include alphanumeric characters and underscores. A class may apply to any number of instances of any elements. An ID may only be applied to a single element. Pseudo-classes are used in CSS selectors to permit formatting based on information that is not contained in the document tree. One example of a widely used pseudo-class is: hover, which identifies content only when the user "points to" the visible element, usually by investment the mouse cursor over it. It is appended to a selector as in a: hover or #elementid: hover. A pseudo-class classifies document elements, such as :link or :visited, whereas a pseudo-element makes a selection that may consist of fractional elements, such as ::first-line or ::first-letter. Selectors may be combined in many ways to achieve great specificity and litheness. Multiple selectors may be joined in a spaced list to identify elements by location, element type, id, class, or any combination thereof. The order of the selectors is important. For example, div .my Class {color: red;} applies to all elements of class my Class that are inside div elements, whereas .my Class div {color: red;} applies to all div elements that are in elements of class my Class. A declaration block consists of a list of declarations in braces. Each assertion itself consists of a property, a colon (:), and a value. If there are multiple declarations in a block, a semi-colon (;) must be inserted to divide each declaration.  Properties are specified in the CSS normal. Each property has a set of possible values. Some properties can affect any type of element, and others apply only to particular groups of elements.  Values may be keywords, such as "center" or "inherit", or arithmetical values, such as 200px (200 pixels), 50vw (50 percent of the viewport width) or 80% (80 percent of the window width). Color values can be specified with keywords (e.g. "red"), hexadecimal values (e.g. #FF0000, also abbreviated as #F00), RGB values on a 0 to 255 scale (e.g. rgb(255, 0, 0)), RGBA values that specify both color and alpha lucidity (e.g. rgba(255, 0, 0, 0.8)), or HSL or HSLA values (e.g. hsl(000, 100%, 50%), hsla(000, 100%, 50%, 80%)). Before CSS, nearly all presentational attributes of HTML documents were contained within the HTML markup. All font colors, background styles, element alignments, borders and sizes had to be explicitly describe, often repeatedly, within theHTML. CSS lets authors shift much of that information to another file, the style sheet, resulting in considerably simpler HTML. For example, headings (h1 elements), sub-headings (h2), sub-sub-headings (h3), etc., are definite structurally using HTML. In print and on the screen, choice of font, size, color and importance for these elements is presentational. Before CSS, document authors who wanted to assign such typographic characteristics to, say, all h2 headings had to repeat HTML presentational markup for each happening of that heading type. This made documents more complex, larger, and more error-prone and difficult to maintain. CSS allows the taking apart of presentation from structure. CSS can define color, font, text alignment, size, borders, spacing, layout and many other typographic characteristics, and can do so in  For example, under pre-CSS HTML, a heading element defined with red text would be written as: <h1><font color="red"> Chapter 1. </font></h1> Using CSS, the same element can be coded using style properties instead of HTML presentational attributes: <h1 style="color: red;"> Chapter 1. </h1> An "external" CSS file, as described below, can be associated with an HTML document using the following syntax: <link href="path/to/file.css" rel="stylesheet"> An internal CSS code can be typed in the head section of the code. The coding is in progress with the style tag. For example, <style> CSS information can be provided from various sources. These sources can be the web browser, the user and the author. The information from the author can be further classified into inline, media type, importance, selector specificity, rule order, inheritance and property definition. CSS style information can be in a divide document or it can be embedded into an HTML document. Multiple style sheets can be imported. Different styles can be applied depending on the output device being used; for example, the screen version can be quite unlike from the printed version, so that authors can tailor the donation appropriately for each medium. The style sheet with the highest priority controls the content display. Declarations not set in the highest priority source are passed on to a source of lower priority, such as the user agent style. This process is called cascading. One of the goals of CSS is to allow users greater control over presentation. Someone who finds red italic headings difficult to read may apply a different style sheet. Depending on the browser and the web site, a user may choose from various style sheets provided by the designers, or may remove all added styles and view the site using the browser's defaulting styling, or may override just the red italic heading style without altering other attributes. CSS was first proposed by Håkon  Wium Lie on October 10, 1994. At the time, Lie was working with Tim Berners-Lee at CERN. Several other style sheet languages for the web were projected around the same time, and discussions on public mailing lists and inside World Wide Web Consortium resulted in the first W3C CSS Recommendation (CSS1) being on the loose in 1996. In particular, Bert Bos' proposal was influential; he became co-author of CSS1 and is regarded as co-creator of CSS.  Style sheets have existed in one form or another since the first phase of Standard Generalized Markup Language (SGML) in the 1980s, and CSS was developed to provide style sheets for the web. One condition for a web style sheet language was for style sheets to come from unlike sources on the web. Therefore, existing style sheet languages like DSSSL and FOSI were not suitable. CSS, on the other hand, let a document's style be influenced by multiple style sheets by way of "cascading" styles.  As HTML grew, it came to cover a wider variety of stylistic capabilities to meet the strain of web developers. This evolution gave the designer more control over site appearance, at the cost of more complex HTML. Variations in web browser implementations, such as ViolaWWW and WorldWideWeb, made dependable site appearance difficult, and users had less control over how web content was displayed. The browser/editor developed by Tim Berners-Lee had style sheets that were hard-coded into the agenda. The style sheets could therefore not be linked to papers on the web. Robert Cailliau, also of CERN, wanted to separate the construction from the presentation so that different style sheets could describe different presentation for printing, screen-based presentations, and editors.  Improving web presentation capabilities was a topic of interest to many in the 

competition for on-screen and printed views. CSS also defines non-visual styles, such as reading speed and emphasis for aural text readers. The W3C has now deprecated the use of all presentational HTML mark up.web the public and nine different style sheet languages were proposed on the www-style mailing list. Of these nine proposals, two were especially influential on what became CSS: Cascading HTML Style  Lie's proposal was presented at the "Mosaic and the Web" conference (later called WWW2) in Chicago, Illinois in 1994, and again with Bert Bos in 1995. Around this time the W3C was already being reputable, and took an interest in the development of CSS. It organized a workshop toward that end chaired by Steven Pemberton. This resulted in W3C adding work on CSS to the deliverables of the HTML editorial review board (ERB). Lie and Bos were the primary technical staff on this aspect of the project, with additional members, including Thomas Reardon of Microsoft, participating as well. In August 1996 Netscape Communication Corporation accessible an alternative style sheet language called JavaScript Style Sheets (JSSS). The spec was never finished and is deprecated. By the end of 1996, CSS was ready to become official, and the CSS level 1 Recommendation was published in December. Development of HTML, CSS, and the DOM had all been taking place in one group, the HTML Editorial Review Board (ERB). Early in 1997, the ERB was split into three working groups: HTML Working group, chaired by Dan Connolly of W3C; DOM Working group, chaired by Lauren Wood of SoftQuad; and CSS Working group, chaired by Chris Lilley of W3C. The CSS Working Group began tackling issues that had not been addressed with CSS level 1, resulting in the creation of CSS level 2 on November 4, 1997. It was published as a W3C Recommendation on May 12, 1998. CSS level 3, which was started in 1998, is still under development as of 2014.user

Sheetsand Stream-based Style Sheet Proposal (SSP). Two browsers served as testbeds for the initial proposals; Lie worked with Yves Lafon to implement CSS in Dave Raggett's Arena browser. Bert Bos implemented his own SSP proposal in the Argo browser. Thereafter, Lie and Bos worked together to build up the CSS standard (the 'H' was removed from the name because these style sheets could also be applied to other markup languages besides HTML).

such as the layout, colors, and fonts. This severance can improve content ease of access, provide more litheness and control in the specification of presentation characteristics, enable multiple HTML pages to share formatting by specifying the related CSS in a separate .css file, and reduce complexity and replication in the structural content. Separation of formatting and content makes it possible to present the same markup page in different styles for different rendering methods, such as on-screen, in print, by voice (via speech-based browser or screen reader), and on Braille-based tactile devices. It can also display the web page differently depending on the screen size or viewing device. Readers can also identify a different style sheet, such as a CSS file store on their own computer, to override the one the author particular. Changes to the graphic design of a document (or hundreds of documents) can be applied speedily and easily, by editing a few lines in the CSS file they use, rather than by changing markup in the documents. The CSS condition describes a priority scheme to resolve which style rules apply if more than one rule matches against a particular element. In this so-called cascade, priorities (or weights) are calculated and assigned to rules, so that the results are predictable. The CSS condition are maintained by the World Wide Web Consortium (W3C). Internet media kind (MIME type) text/css is registered for use with CSS by RFC 2318 (March 1998). The W3C operates a free CSS legalization service for CSS documents.

interfaces written in HTML and XHTML, the language can be practical to any XML document, including plain XML, SVG and XUL, and is pertinent to rendering in speech, or on other media. Along with HTML and JavaScript, CSS is a foundation technology used by most websites to create visually appealing web pages, user interfaces for web applications, and user interfaces for many mobile applications.

In 2005 the CSS Working Groups decided to enforce the necessities for standards more strictly. This meant that already published standards like CSS 2.1, CSS 3 Selectors and CSS 3 Text were pulled back from Candidate Recommendation to Working Draft level. The CSS 1 specification was done in 1996. Microsoft's Internet Explorer 3 was on the loose in that year, featuring some limited support for CSS. IE 4 and Netscape 4.x added more support, but it was typically incomplete and had many bugs that prevented CSS from being usefully adopted. It was more than three years before any web browser achieved near-full accomplishment of the specification. Internet Explorer 5.0 for the Macintosh, shipped in March 2000, was the first browser to have full (better than 99 percent) CSS 1 support, surpassing Opera, which had been the leader since its introduction of CSS support 15 months earlier. Other browsers followed soon afterwards, and many of them additionally implemented parts of CSS 2. However, even when later 'version 5' browsers began to offer a fairly full implementation of CSS, they were still incorrect in positive areas and were fraught with inconsistencies, bugs and other quirks. The inconsistencies and variation in feature support made it not easy for designers to achieve a consistent appearance across browsers and platforms, leading to the use of workarounds such as CSS hacks and filters. Problems with browsers' patchy espousal of CSS, along with errata in the original specification, led the W3C to revise the CSS 2 standard into CSS 2.1, which moved nearer to a working snapshot of current CSS support in HTML browsers. Some CSS 2 properties that no browser successfully implemented were dropped, and in a few cases, defined behaviors were changed to bring the standard into line with the predominant existing implementations. CSS 2.1 became a Candidate counsel on February 25, 2004, but CSS 2.1 was pulled back to Working Draft status on June 13, 2005, and only returned to Candidate Recommendation status on July 19, 2007.  In addition to these problems, the .css extension was used by a software product used to convert PowerPoint files into dense Slide Show files, so some web servers served all .css as mime type application/x-pointplus rather than text/css.