LINUX

Linux is a free Unix-type operating system originally created by Linus Torvalds with the assistance of developers around the world. Developed under the GNU General Public License , the source code for Linux is freely available to everyone.

Richard Matthew Stallman
(Founder of GNU)

Here ‘FREE’ means not only the free of cost, actually it gives 4 freedoms

# The Freedom to Use
# The Freedom to Modify
# The Freedom to Copy
# The Freedom to Redistribute Changes

Linus Torvalds
(Inventor of Linux Kernel)

Why we need Linux?

# Freedom
# Virus free
# Stability & Security
# Multi-user
# Installing Softwares becomes In SINGLE-CLICK
# No PROPRIETARY issues
# Don’t wait years to fix the bugs
# It can run for years without restarting
# Jump in to Next generation of computers
# Do something for world
# An excellent window system called X
# Supports multiple processors as standard
# True multi-tasking
# You can try Linux without touching the OS which already you have
# Get great music players
# Play hundreds of games for free
# Last but not least Enjoy free and unlimited support

How can we get Linux ?

# By downloadind from corresponding site
# By getting the CDs from your city
# By asking CDs through mail

What are all have Linux?

Here I mentioning few

(1) Server Side

# DNS Server      –    BindDNS
# Mail Server       –    Postfix
# Web Server     –    Apache
# DB Server        –    Mysql
# File Server       –    NFS & Samba
# Print Server     –    CUPS
# Firewall            –        IPTABLES
# Proxy Server   –    Squid
and many more…..

(2) Development Side

# GUI related
* X Window System
* GNOME
* KDE
* Xfce desktop environments
# OpenOffice.org for office suite
# Mozilla for Firefox for web browsers
# Thunderbird email client.
# Typesetting and document preparation systems
* TeX
* LaTeX
# Graphics tools
* GIMP raster image editor
* Inkscape vector graphic editor
* Paint.NET raster drawing program
* Blender 3D animation program
# Text editors like vi or emacs.

Some Linux Distributions

# Debain based distros like ubuntu

# Redhat based distros like fedora,centos

# Mandriva based distros like mandrake

LUG (Linux User Group)

A Linux User Group or Linux Users’ Group (LUG) is a private, generally non-profit or not-for-profit organization that provides support and/or education for Linux users, particularly for inexperienced users.

For our city  it is ilugc , which is doing some great works here.

• open the executable file using wine.

To enable audio in skype  run the following commands in terminal:

killall pulseaudio

sudo apt-get remove pulseaudio

sudo apt-get install esound

sudo apt-get install pulseaudio

Powerful and Simple

Ruby on Rails questioned prior assumptions and opened up a new way to create web applications that emphasized simplicity and productivity.

Developing in Rails means:

• a lot less code
• a lot less configuration data
• bringing up basic functionality quickly
• building out new functionality incrementally
• integrated testing

Advantages of Ruby on Rails

1. Don’t repeat yourself(DRY):

Every element of the web application has its specific place and doesn’t have to be repeated multiple times across files.

2. Convention over configuration:

By using practical conventions, most configuration data can be eliminated (however the conventions can be overridden with configuration when necessary).

3. Quick turn-around time:

By providing an integrated web server and an interpreted language, the results of code modifications can be seen immediately, thereby minimizing the code-debug cycle (with no additional compile step).

4. MVC architecture:

ruby on rails is based on model view controller architecture that helps in dividing the whole application into layers

Separation of business logic from database logic and from user interface is handled cleanly, decreasing coupling and providing the benefits of orthogonality

5. Active Record:

The core concept of Active record and other object relational mapping libraries is that relational database can be represented reasonalbly in object-based code if you think of database tables as classes,table rows as objects, and fields as object attributes.

6. Single-stack application framework:

Ruby on Rails includes all the components necessary to build complete web applications from the database forward (even including a pure-Ruby web server for those who wish to develop immediately without setting up a web server such as Apache or lighttpd), providing object-database linkage, unit and functional testing tools, stylesheets, support for multiple templating systems, multi-environment deployments, support for automated local and remote deployments (via the included Switchtower utility), inbound and outbound email support, web services support, etc.

7. Database agnosticism:

Rails supports a wide array of databases, including all the common production database platforms. Developing, testing, and deploying Rails on multiple databases simultaneously is very successful.

8. AJAX UI support:

The most viable technology for streamlining user interaction is AJAX (“Asynchronous JavaScript and XML”). Ruby on Rails’ support for AJAX is powerful, flexible, terse, and well-integrated into the framework. The development of the Prototype AJAX library (a popular AJAX and JavaScript effects library) has been driven by Rails development feedback.

9. Integrated unit and functional testing support:

Testing in Rails is simple, well-documented, terse, and integrated into the Rails framework. Rails builds the necessary scaffolding for unit and functional tests automatically, and tracks test/code ratios automatically. Rails includes native support for mock object testing and database fixtures, streamlining out-of-container testing.

10. Web services support:

Rails supports the most popular web services protocols, including XML-RPC, SOAP, and WSDL. Rails’ flexibility with regard to external APIs enables addition of further web services interfaces easily. The popular Rails weblogging software Typo serves as an open example of the ease with which new APIs can be added to Rails applications.

Work around for this problem is to add the following in beginning of PHP code:

ini_set(“session.save_handler”, “files”);

The “save_handler” is just defined in php.ini with value “files”, redefining the save_handler before calling session_start() solves the problem.

• Rule #1- Figure out what business you are in, and then mind your own business. Figure out what business you are in.  Make sure your business is viable.  Select projects that are good for your business.  Understand the business value in your project and watch for changes.  Be diligent in your chosen business, learning and applying best practices.  Define what is inside and outside your area of responsibility.  50% of project management is simply paying attention.
• Rule #2 – Understand the customer’s requirements and put them under version control. Thoroughly understand and document the customer’s requirements, obtain customer agreement in writing, and put requirements documents under version identification and change control.  Requirements management is the leading success factor for systems development projects.
• Rule #3 – Prepare a reasonable plan. Prepare a plan that defines the scope, schedule, cost, and approach for a reasonable project.  Involve task owners in developing plans and estimates, to ensure feasibility and buy-in.  If your plan is just barely possible at the outset, you do not have a reasonable plan.  Use a work breakdown structure to provide coherence and completeness to minimize unplanned work.
• Rule #4 – Build a good team with clear ownership. Get good people and trust them.  Establish clear ownership of well-defined tasks; ensure they have tools and training needed; and provide timely feedback.  Track against a staffing plan.  Emphasize open communications.  Create an environment in which team dynamics can gel.  Move misfits out.  Lead the team.
• Rule #5 – Track project status and give it wide visibility. Track progress and conduct frequent reviews.  Provide wide visibility and communications of team progress, assumptions, and issues.  Conduct methodical reviews of management and technical topics to help manage customer expectations, improve quality, and identify problems before they get out of hand.  Trust your indicators.  This is part of paying attention.
• Rule #6 – Use Baseline Controls. Establish baselines for the product using configuration management and for the project using cost and schedule baseline tracking.  Manage changes deliberately.  Use measurements to baseline problem areas and then track progress quantitatively towards solutions.
• Rule #7 – Write Important Stuff Down, Share it, and Save it. If it hasn’t been written down, it didn’t happen.  Document requirements, plans, procedures, and evolving designs.  Documenting thoughts allows them to evolve and improve.  Without documentation it is impossible to have baseline controls, reliable communications, or a repeatable process.  Record all important agreements and decisions, along with supporting rationale, as they may resurface later.
• Rule #8 – If it hasn’t been tested, it doesn’t work. If this isn’t absolutely true, it is certainly a good working assumption for project work.  Develop test cases early to help with understanding and verification of the requirements.  Use early testing to verify critical items and reduce technical risks.  Testing is a profession; take it seriously.
• Rule #9 – Ensure Customer Satisfaction. Keep the customer’s real needs and requirements continuously in view.  Undetected changes in customer requirements or not focusing the project on the customer’s business needs are sure paths to project failure.  Plan early for adequate customer support products.
• Rule #10 – Be relentlessly pro-active. Take initiative and be relentlessly proactive in applying these principles and identifying and solving problems as they arise.  Project problems usually get worse over time.  Periodically address project risks and confront them openly.  Attack problems, and leave no stone unturned.  Fight any tendency to freeze into day-to-day tasks, like a deer caught in the headlights.

A common time management mistake is to try to use your memory to keep track of too many details leading to information overload. Using a to-do list to write things down is a great way to take control of your projects and tasks and keep yourself organized.

2. Prioritize your list

Prioritizing your to-do list helps you focus and spend more of your time on the things that really matter to you. Rate your tasks into categories using the ABCD prioritization system described in the time management course.

3. Plan your week

Spend some time at the beginning of each week to plan your schedule. Taking the extra time to do this will help increase your productivity and balance your important long-term projects with your more urgent tasks. All you need is fifteen to thirty minutes each week for your planning session.

4. Carry a notebook

You never know when you are going to have a great idea or brilliant insight. Carry a small notebook with you wherever you go so you can capture your thoughts. If you wait too long to write them down you could forget. Another option is to use a digital recorder.

5. Learn to say no

Many people become overloaded with too much work because they overcommit; they say yes when they really should be saying no. Learn to say no to low priority requests and you will free up time to spend on things that are more important.

6. Think before acting

How many times have you said yes to something you later regretted? Before committing to a new task, stop to think about it before you give your answer. This will prevent you from taking on too much work.

7. Continuously improve yourself

Make time in your schedule to learn new things and develop your natural talents and abilities. For example, you could take a class, attend a training program, or read a book. Continuously improving your knowledge and skills increases your marketability, can help boost your career, and is the most reliable path to financial independence.

8. Think about what you are giving up to do your regular activities

It is a good idea to evaluate regularly how you are spending your time. In some cases, the best thing you can do is to stop doing an activity that is no longer serving you so you can spend the time doing something more valuable. Consider what you are giving up in order to maintain your current activities.

9. Use a time management system

Using a time management system can help you keep track of everything that you need to do, organize and prioritize your work, and develop sound plans to complete it. An integrated system is like glue that holds all the best time management practices together.

10. Identify bad habits

Make a list of bad habits that are stealing your time, sabotaging your goals, and blocking your success. After you do, work on them one at a time and systematically eliminate them from your life. Remember that the easiest way to eliminate a bad habit, it to replace it with a better habit.

Single sign on requires that users literally sign in once to establish their credentials. Systems which require the user to log in multiple times to the same identity are inherently not single sign on. For example, an environment where users are prompted to log in to their desktop, then log in to their email using the same credentials, is not single sign on.

As different applications and resources support different authentication mechanisms, single sign-on has to internally translate to and store different credentials compared to what is used for initial authentication.

Benefits of SSO:

* Reduces phishing success, because users are not trained to enter password everywhere without thinking.
* Reducing password fatigue from different user name and password combinations
* Reducing time spent re-entering passwords for the same identity
* Can support conventional authentication such as Windows credentials (i.e., username/password)
* Reducing IT costs due to lower number of IT help desk calls about passwords
* Security on all levels of entry/exit/access to systems without the inconvenience of re-prompting users
* Centralized reporting for compliance adherence.

SSO uses centralized authentication servers that all other applications and systems utilize for authentication purposes, and combines this with techniques to ensure that users do not actively have to enter their credentials more than once.

Enterprise single sign-on

Enterprise single sign-on (E-SSO) systems are designed to minimize the number of times that users must type their ID and password to sign into multiple applications. The E-SSO solution automatically logs users in, and acts as a password-filler where automatic login is not possible.

Some E-SSO solutions focus on delivering quick return on investment and shy away from requiring complex infrastructure hardware additions. These solutions are generally software-based agents which roam with the user and automate the process of login and password change for the desired applications (Win/Java/Ajax/Web/Terminal Emulator). The benefit of this approach is that users can have any username/password for the target systems/applications because from the E-SSO agents perspective they are all just ‘credentials’ to store. Given that user credentials may be cached locally (and sync’d to a central repository) the use of strong encryption as well as reliable and viable key recovery options are suggested for the chosen E-SSO technology.

Ideally, there is no need for the users to actually have a first hand understanding of their assigned credential(s) for end applications after implementation of E-SSO, and as an upside once users have confidence in this way of thinking application owners are encouraged to increase password length and complexity such that the user could not easily remember the password on their own.

There is also a significant security upside with client side E-SSO solutions. Given that the user’s credentials are now stored in a very secure cryptographically locked store and that the users themselves no longer know (or care to know) the applications credentials, it’s possible to ‘release’ (logon with) certain credentials based on a defined ‘authentication grade’. Two factor authentication systems such as smart cards or biometrics can be linked to different authentication grades. A user might for example have 10 sets of credentials in their encrypted store, for 10 different applications. Applications 1 through 6 might simply require that the user has shown to have successfully logged in to the primary domain (i.e. Windows Active Directory, etc) but when the E-SSO client goes to log on the user to applications 7-10 it might check for the insertion/presence of a smart card with valid user keys on it. By doing this the enterprise has effectively implemented two factor authentication but have not had to deal with the challenges of back-end infrastructure additions/application modifications, etc.

With client-side E-SSO solutions enterprises can very easily transition from a regime where passwords are easily brute forced and authentication is single factor to a scenario where high yield applications are now two factor authentication access controlled, passwords are complex and users don’t know them, hence hackers cannot effectively brute force applications with dictionary or rainbow tables.

Poor exception-handling implementations can spoil even the best design. There should be an agreement on a reasonable exception-handling style for your application and following a consistent set of exception-handling practices is crucial to implementing software that’s easy to maintain, enhance and improve. The longer you avoid exceptions, the harder it is to wedge cleanly designed exception-handling code into working software. To demystify exception-handling design, we must more widely accept and follow proven techniques, guidelines, and patterns.

Exception basics: An exception is an condition which occurs when a component/object ends prematurely when trying to fulfil a responsibility. As mentioned above exceptions are of different types, but on a general perspective an exception is an indication that a part of a program has encountered an error situation. Exceptions can be broadly categorized into two, one is the ‘Exception’ itself, which can be usually caught/thrown/delegated in a way the programmer intends to do it. Uncaught exceptions are generally caught by the runtime environment and are thrown to the caller. One more type of exception is usually referred to as ‘Error’ which is not usually caught by the user programmatically, this is an unusual condition which is naturally dealt with by the runtime environment.

Exceptions can be further categorized into two types, one is compiler exceptions, where the compiler enforces a rule that these exceptions should be generally caught/thrown in the program. This general rule is enforced because it is a way to indicate to the programmer that this exception can occur, hence program a possibility to handle this in case it occurs. The next type is runtime exceptions, this can also be referred to as programmatical errors which should be resolved during the coding/review phase, if not, atleast when unit tests are carried out.

Few general rules to remember/follow while dealing with exceptions:
1. Don’t try to handle coding errors.
2. Limit Declaration of custom exception classes.
3. Name an exception class with reference to the error cause and not with reference to the origin of the exception.
4. Provide more details about the context along with the exception.
5. Handle exceptions as specific or close to the problem you can.
6. Use exception handling only to signal emergency situations.
7. Don’t re-throw the same exception.
8. Last but most important is Log your exceptions, use a application logger utility.

Though this article seems to be a short one, it covers a lot of ground in reality and gives a high-level description of most of the areas in Exception handling.

1. Avoid use of too many containers in the flex application.
   Flash Player uses a hieratical display object graph. The deeper containers are nested the longer the rendering takes by hindering the performance of your application. As per Adobe it is 100 percent avoidable.
2. Avoid use of very long animations
   Most animations are simply TOO LONG and they will annoy users. Developers should make sure that the animations have meaning and provide context.
3. Avoid use of complicated itemRenderers in List, Datagrid
   As mentioned in the first point, ItemRenderer is one of the place where containers can get deeply nested. The number of item renderers which are rendered by the DataGrid is the number of visible rows times the number of visible columns. This slows down the applications. When complex layout logic is needed in an item renderer, it is best to use UIComponent (or other more low-level classes) and position the contents for that cell manually.
4. Make use of Runtime Shared Libraries (RSL)
   Runtime Shared Libraries (RSL) is available for reducing the size of your applications.



August 25-26 is the spot to be for all  RIA people, Irrespective of Flex/Flash or Silverlight etc. As a company who build RIA we will be there to learn and explore new opportunities available there. For people who don’t know about the event they can logon this website and check it out http://www.developermarch.com/adobesummit/ .

You can get additional 10% discount if you book with help of http://www.ria-rui.org/ till June 25.