Tahsin’s Reading List (Books): Software Engineering (Computer Science in Practice)

‘El Clasico’, The Classics

Modern Practices

Academic Study of Software Engineering

Software Architecture

OOP & Design Patterns

Test Driven Development

Software ‘Tools of the Trade’

Experts’ Opinion Compilation

Tahsin’s Reading List: Programming Languages (Computer Science in Practice)






Common Lisp



আজকের উপলব্ধিতে নাগরিক ঐক্য [১৩.০৬.১৫]

নাগরিক ঐক্য #Nagorik

তথ্য ও যোগাযোগ প্রযুক্তি Information and Communications Technology

“সেমিনারটির আয়োজন করে ডিআইআইটি এবং এমআইএসসি। সেমিনারের উদ্বোধন করেন ড্যাফোডিল গ্রুপের চেয়ারম্যান মো. সবুর খান ( #Nagorik )।”

বড় Engineering প্রজেক্ট সম্পূর্ণভাবে বাংলাদেশীদের মাধ্যমে সম্পন্ন করতে – আমাদের ডেভেলাপারদের এবার বড় আকারের সফটওয়্যার ডেভেলাপমেন্টের সক্ষমতা অর্জন করতে হবে।

WordPress Plugin. Theme Development এর মাঝে নিজেকে সীমিত রাখলে চলবে না, WordPress এর মত একটা CMS নিজে কিভাবে develop করা যায় – ভেবে বের করতে হবে।

শুধু Android Activity, Services লেখা না – ভাবতে হবে – আমিই যদি Android এর মত একটা Smartphone OS develop করতাম – কিভাবে করতাম?

সেরা ডেভেলাপার হতে চাইলে জানতে হবে Under the hood – “Hadoop” কিভাবে কাজ করে, নিজে অমন একটা Mapreduce Framework কিভাবে Develop করা যায়। শুধু “Map” আর “Reduce” লিখতে জানলেই চলবে না !

অর্থনীতি ও বাণিজ্য Business & Economy

“Bikroy.com বিক্রেতার অনুরোধে একজন প্রতিনিধি পাঠাবে যিনি বিক্রেতার পণ্যটি সংগ্রহ করে তা ক্রেতার কাছে পৌঁছে দেবেন। একইভাবে পণ্য বিক্রির টাকা আবার বিক্রেতাকে পৌঁছে দেবেন। Bikroy.com এর কাস্টমার সাপোর্ট টিম ক্রেতা-বিক্রেতা উভয়ের জন্য একটি সুবিধাজনক সময় নির্ধারণে সাহায্য করবেন।”

পরবর্তী ধাপে Bikroy.com কে “E-Commerce Platform” হিসেবে গড়ে তোলা হবে।

ব্যাপারটা Shopping Mall এর সাথে তুলনীয়।

Shopping Mall -এ 3rd Party যেমন নিজস্ব Store গড়ে তুলতে পারেন, Bikroy.com “Platform” এর ওপর যে কেউ নিজস্ব “e-Store” গড়ে তুলতে পারবেন

  • অর্থ আদানপ্রদান
  • পণ্য পৌছে দেওয়া
  • E-Commerce Website & App Development
  • Data Analytics
  • Supply Chain Management (SCM) Software, Inventory Management Software
  • Sales Forecasting & Prediction for clients (Internal Team)

– প্রত্যেকটির সম্পূর্ণ দায়িত্ব নেবে Bikroy.com.

দেশের উদ্যোক্তাদের জন্য দারুণ সুযোগ #EntrepreneurshipDevelopment

মাদকমুক্ত বাংলাদেশ  #StopDrugTrafficking  #Nagorik


International Relations

100X Productivity Gains For Software Engineers : A Brief Sketch Of My Approach

1ooX Productivity Gains For Software Engineers: A brief sketch of my approach

Here is a sketch of “Software Development Process” that would bring about massive Productivity gains for Programmers.

Current approach:

Only “Infrastructure” Code is reusable across applications. The Programmer has to write the “Domain Specific” Code from scratch.

I will define specifications (Example: JavaEE specifications) so that programmers can write “Domain Specific” reusable (and modifiable) Components and others can glue those components together into Software.


Hadoop (Infrastructure Code) and Spring (Infrastructure Code) are reusable. But, In case of Hadoop, the programmer has to write the “Map” and “Reduce” functions (“Domain Specific Code”) from scratch.

I will write specifications – so that people can write “Domain Specific Reusable Open Source Components” and later reuse those Components to build Software.

In today’s terms, it means not having to write “Map” and “Reduce” (of Hadoop) from scratch, but reusing pre-written Components and gluing them together.

“Domain Specific Reusable Code” will be modifiable (to suit your need) by changing values in a separate file, just like today you can modify Hadoop through its Configuration files.

You will join those pieces (or Components) of “Domain Specific Code” together through a OSGi-like module layer.

One important perspective: In the above mentioned approach, do not think in terms of “Code”, rather think, as you would if you were playing with a LEGO set (modular pieces):

what “Modules” you have in your “Code” toolbox

how you would join those “Modules” or “Pieces” together.

I am expecting 100X or more productivity gains.

Other Articles related to Productivity gains for Programmers:

"Real Object Programming": A New Programming Paradigm

“Real Object Programming”: A New Programming Paradigm
Imagine, how easy life would become for you as a developer if the “symbols” you manipulate in your program were real world entities containing real world data.Let me give you an example.

In such a system, “Washington, DC” might be provided as a “symbol” in your language API, which you can manipulate to get data about the US capital Washington, DC.


>> “Washington, DC”.area 

would give the area of Washington, DC.

This is something different, right?

Now, consider a Cloud Computing Service which provides API for “Real Object programming”.

So one would be able to write

max [for all state.capital.area in “United States”]

to get the state capital of The United States with the highest area.

This would increase productivity of Software Developers by several orders of magnitude.

Welcome to a new kind of programming – “Real Object Programming”!

Real Object Programming is
A form of symbolic programming where
“symbols” in your program represent real world objects and processes
with “data” extracted from the real world.

Programmers write code that attempt to simulate some part of the world we live in or create an imaginary world (e.g., in Games or Virtual Reality).
So in essence, programmers try to approach “Real Object Programming”.

But no systematic way of study or no distinctions has been made thus far.

Some areas where we see glimpses of “Real Object Programming”

  • AI
  • Semantic Web (Graph Database, RDF, OWL)

But the only real work thus far: Wolfram Language.


A few Features of “Real Object Programming”:

  1. Real Object Programming requires integrated Ontology for interoperability between different symbols (Objects, Processes).
    • Use of Knowledge Ontology ensures that objects and functions from different domains work together. Each object representing real world entities is declared in the Knowledge Ontology.
    • Consider, your symbol of “Washington DC” and someone else’s (from France) symbol “Paris”. If you want to make sure that a third person is able to able to write code with both “Washington DC” and “Paris”, you need a general Ontology.
  2. The programming model for Real Object Programming (ROP) would be different from OOP because in OOP, the class declares methods that manipulate states of the object. ROP requires that, function from one domain can work with object from another domain (the function is not declared in the class from which the object is formed).

Programming Languages I Am Learning – Focusing On

Programming Languages I Am Learning – Focusing On And The Reasons Behind Choice

  1. C/C++
    • Systems (Linux, Android, Chrome) Programming 
    • Efficiency. Memory manipulation. Complete control over the environment. 
  2. Go 
    • Systems, Concurrent and Networked Programming 
    • Static Typing
    • Faster compilation 
  3. Java 
    • Managed Code
    • Android Application Development
    • Open Source Libraries and Frameworks
  4. Scala 
    • A blend of all the features you ever saw in different languages! 
    • Tries to answer “So, if we want to let programmers implement this feature as language library rather than language syntax, what features do we need to introduce in the language?” 
      • Features: 
        • Actors Library 
        • Operators as Functions 
        • Flexible syntax (Prefix, Infix, Postfix mixing) 
      • Makes Scala DSL friendly and “scalable”.
      • Makes the core language small (rest of the features are implemented in the library). Lisp Philosophy. 
    • What happens when you try to fuse OOP and Functional Programming on JVM? 
    • Static Typing and Terse syntax
    • Concurrent and Distributed Programming
  5. Clojure 
    • Lisp on JVM
    • Metaprogramming (Programmable Language) 
    • Functional Programming
    • Concurrent Programming
  6. Python 
    • Rapid Development
    • Open Source Libraries and Frameworks
  7. Ruby
    • Object Oriented, Dynamic, Scripting Language
    • Metaprogramming Facilities
    • Ruby on Rails
  8. JavaScript 
    • Web Front-end (with HTML5 & CSS)
    • Object-based Programming 
    • Node.JS
    • Statistical, Numerical Computing 
  9. Haskell
    • Purely Functional Programming
  10. Erlang
    • Fault-tolerant Real-time Parallel Distributed Computing
    • Modifiable without downtime

Current Preference

    If you need complete control over the environment, go down to C++. Otherwise, use Scala, Java. 

    Machine Learning Algorithms: Brief Introduction

    Machine Learning Algorithms: Brief Introduction

    Supervised Learning
    You have examples of inputs and outputs. You have to learn a model that turns inputs into outputs.

    • Decision Tree Learning
      • If you want to learn a propositional logic-based theory.
      • Learning from features 
        • Propositional sentences on features.
        • If 18 < age < 35, sex = male, location = Chittagong, Then the person is likely to vote for “Nagorik Shakti”.
    • Bayesian Learning
      • Flat input (vectors, etc.); not features.
        • Language Applications heavily use Bayesian Learning.
      • Counting occurrences (Frequency – Probability). 
      • Apply Bayes rule; rigorous definition of terms – not required; rather define terms to suit your purpose and computational power. 
    • Neural Network Learning
      • Learn weights on inputs.
        • Learning parameters of equations. 
    • Genetic Programming
      • You join programs together, mutate programs to see if your program can generate required outputs from inputs.
      • How do you represent programs?
        • You represent programs as trees (remember Context free grammar – CFG?) Lisps are natural, but any language can be used. 

    Knowledge Based Learning

    You have some knowledge. As you gain new knowledge, how do you incorporate it to your existing knowledge base?

    • Explanation Based Learning
      • You solve a problem and extract general principles from your solution for future reuse to other problems.
      • Suppose, you have logically inferred that A => B => C => D. Then you can conclude (and learn) that A => D. From that point on, whenever you see A, you can replace it with D. This is Explanation Based Learning in action.
      • One kind of memoization (storing results to avoid recomputation), but much more general.
    • Relevance Based Learning
      • You know a general rule. You learn something. And then using the general rule that you knew before and the newly learned knowledge, you infer (learn) a new generalization.
      • You knew A & B => C. You learn that A and B are true. You infer (learn) that C is true.
    • Inductive Logic Programming
      • From examples of logical sentences, you infer (and hence learn) general rules.
      • Example: From examples of family relations (say, Jack is Father of Anthony, Sam is Grandparent of Jill, etc. you learn that
        • for all Z and X, Grandparent(Z, X) => Parent(Z, Y) & Parent(Y,X) for some Y. 
        • Can induce new terms / relation. For example, ILP can learn “Parent” from examples of Father and Mother relations.
        • Inductive Logic Programming has been used to make Scientific Discoveries
          • Learning new relations and predicates are as important a step in scientific discovery as forming new rules. Introduction of the concept “acceleration” helped Newton form his famous law F (force) = ma (mass * acceleration). Without the concept of acceleration (which Galileo had invented earlier), it would have been very difficult for Newton to come up with a law that describes relationship between Force and rate of change in position of an object.
          • In the above example, we saw that our ILP program invented the concept “Parent” and used it to learn (and compactly represent) the rule for “Grandparent”.

    More on Machine Learning

    This is my 200th Post on tahsinversion2.blogspot.com!

    Distributed Data Processing Frameworks

    Distributed Data Processing Frameworks

    Dependency Injection: Newbie’s Guide

    In different branches of Engineering, Engineers design their intended devices from off-the-shelf components. They glue together components (resistors, transistors, electromagnets, etc.) through well defined interfaces (buses in case of computers) to build devices.

    This is not the case in Software Engineering. Glueing software components together to build large Softwares have proven an illusive goal.

    Nevertheless, Software Developers are always looking forward to reuse components or code – whether written by themselves or by others.

    The problem – in the Software Development world, change is the norm.

    So, how do you write Software that is flexible and maintainable?

    Lets find out what the problem is. 

    Suppose component B has a method b().
    A calls B.b().
    When we write Z, we call B.b().

    But if B is replaced with G.
    A can’t call B.b() anymore.
    A’s B.b() has to be replaced with G.g() or equivalent.

    So, in our current scheme, if we want to replace B with G,
    not only do we replace B but we have to replace component A with another component X.

    In general, if our code (in this case, component A) is dependent on other code (component B, C, D), then if the dependencies (any of B, C, and D) change, we have to change the dependent code (component A) as well.

    Is there a way so that we can replace dependencies (B or C or D) without replacing dependents (A)?

    Yes! Dependency Injection to the rescue!

    Dependency Injection Frameworks enable us to inject dependencies to the dependents.

    So if any of the dependencies change, we inform it to our Dependency Injection framework and the DI framework does the job of injecting the new component to dependents.

    Each Dependency Injection framework has its own way of accomplishing the task.

    For example, in game playing, we can write MiniMax Algorithm that returns us the next move by computer. The Algorithm is dependent on the game. We can inject any game (Dependency) we want, be it tic-tac-toe, chess, whatever.

    Dependency Injection Frameworks

    Projects For Programmers

    A list of Projects For Programmers.

    Anyone out there looking for challenges?

    • Area: Software Engineering
      • Programming Language
        • Design a new Programming Language. Write an Interpreter for the language. 
          • Interpreter for your own Lisp.
        • Personal Note: While I was in College, I used to dream of inventing – not just an “YAPL” – “Yet Another Programming Language” but a great programming language that would take the Software World by storm! This project would be a great practice for that yet-to-be-named programming Language!
      • Software Engineering Tools
        • Write a “mini” Dependency Injection Framework. 
        • Write a Code Generation Tool that generates project structure, classes, fields, methods, creates Database from XML / YAML. 
          • Examples: 
            • Ruby on Rails 
            • Spring Roo
      • Area: Theoretical Computer Science
        • Solve TopCoder [1] and Google Codejam [2] Problems. 
      • Area: Intelligence and Data
        • Implement Natural Language Parsing.
          • Use your Dependency Injection Framework to inject different Algorithms.
            • Top down Parsing 
            • Chart Parsing
        • Implement Minimax Algorithm with Alpha-Beta pruning on a simple game.
          • Use your Dependency Injection Framework to inject different games into the Algorithm (so that you can inject any game you wish). 
        • Prototype a Web Search Engine on a small number of Wikipedia pages.
        • Analyze Political Survey Data with 
          • Hadoop, Mahout
          • Spark, MLib
        • Prototype Web-based Email with anti-spamming feature.
          • Implementation of Machine Learning (Bayes)
        • Area: Systems
          • Mobile Development
            • Mini Android Apps
              • Develop a “Who wants to be a Millionaire” App.
          • Virtualization
            • Design a Virtual Machine. 
          • Database
            • Design and implement a prototype RDBMS Server (RDBMS lite).
            • Design and implement a prototype NoSQL Server
              • Graph Database Server.
          • Write a Mini Web Browser.
            • Use Google’s JavaScript V8 Engine.
            • Networking & Distributed Computing
              • Design and Implement a new Application Layer Protocol.
                • Protocol that supports Internet Of Things, Cloud, Mobile.
                • New Full-duplex protocol on top of HTTP 
                  • Current:
                    • WebSocket 
                    • Comet
                • Prototype your own Mapreduce framework.
                • Prototype an HTTP Server.
                  • Use Node.JS
                  • Prototype an E-Mail Server. 
                • Write a Django CMS on Google App Engine (datastore).
                • Write a Distributed Application with Java Spring Framework.
                  • Write a PC^2 equivalent Software for Programming Contests.
                  • Write Personal News / Blog Reader and Bookmark Manager for personal use.
                  • Design Ebook App.
                    • Interactive HTML5 EBook with advanced Mobile Interactions.


              Computer Science Skillsets

              Computer Science Skillsets

              • Skillset 1: Software Engineering
                • Programming Languages [1] [2]
                • Software Engineering skills, tools and processes [3] [4] [5] [6]
              • Skillset 2: Theory & Algorithms 
                • Theoretical Computer Science
                  • Algorithms [1] [2]
                  • Data Structures
                  • Language, Automata & Discrete Mathematics
                • Computational Science & Engineering
              • Skillset 3: Systems
                • Systems Programming
                • Computer Security
                • Database: RBBMS and NoSQLs
                • Cloud and Mobile Development [1] [2]
                • Parallel, Multicore and Concurrent Programming [3]
                • Networked and Distributed Systems Programming [4] [5] [6] [7]
                • Wireless Networks & Mobile Computing
              • Skillset 4: Intelligence & Data 
                • Machine Learning [1]
                • Data Science & Analytics, Big Data 
                • Artificial Intelligence [2]
                • Language Processing: Statistical / Natural
                • Computer Vision, Image Processing
                • Robotics 
              • Skillset 5: Physical Digital Computing [1] [5] 
                • Robotics & Manufacturing [2] [3] [4] [6]
                • Internet Of Things
              • Skillset 6: Info Bio 
                • Computational Biology & Bioinformatics
                • Systems BIology [1] 
                • Healthcare Informatics
              • Skillset 7: Interactive Computing
                • Education [1] [2] 
                • Wikinomics [3] [4]


              Software Engineering

              1. Programming Languages I Am Learning / Working With
              2. Programming Language Paradigms
              3. Java Development Skills
              4. Functional Programming: A Brief Introduction
              5. The Story of Object Oriented Programming
              6. Dependency Injection: Newbie’s Guide

              Theoretical Computer Science 

              1. Organization Of The Study And Application Of Algorithms
              2. Solving Programming Problems


              1. Android Development Topics A Developer Needs To Master
              2. Android Application Architecture
              3. Concurrent Programming Models
              4. The Story Of Computer Networking: Progression From Internet To Web and Cloud
              5. Graphical Representation Of Django Web Framework Components
              6. How Web Search Engines Work
              7. Distributed Data Processing Frameworks

              Intelligence & Data

              1. What is Machine Learning?
              2. Overview of (Artificially) Intelligent Agents

              Physical Digital

              1. Emerging Area: Physical Digital Integration
              2. Physical Digital Integration: Cloud Manufacturing & Car 2.0
              3. Smart Home With Physical Digital Integration: What The Future Holds
              4. Could Manufacturing Be The Key To American Lead In Global Economy?
              5. The Science of Reading: Paper versus Screens
              6. On The Future Of Manufacturing: From Scientific American

              Info Bio

              1. Studying Medicine

              Interactive Computing

              1. Fundamental Shift In Education – A Requirement Of Our Time
              2. Vision Of “World Wide Education Platform” (WWEP!)
              3. Vision Of Collaborative Research Platform
              4. Wikinomics Platforms And Services
              5. Academic Institutions
                1. School Of Interactive Computing, Georgia Institute Of Technology
                2. MIT Media Lab, Massachusetts Institute Of Technology 


              1. প্রোগ্রামিং এ হাতেখড়ি


              Functional Programming: A Brief Introduction

              Functional Programming Languages provide 2 main features:

              1. First class functions 
                • which means functions are first-class citizens.
                  • functions can be assigned to variables
                  • functions can be stored in data structures
                  • functions can be passed to other functions as arguments
                  • functions can be returned from other functions
              2. Pure functions without any side-effect
                • Functions take values as parameters and return values.
                • No global or mutable state.

              What do these two features lead to

              • Localized thinking space 
              • Localized testing 
              • Control abstraction with higher order functions
              • More readable & shorter code
                • Higher order Functions leads to less branches and assignments, which in turn leads to readable, shorter code. 
              • Data abstraction with closures
              • Concurrency – immutable data structures
              • Simplifies programming. No need for complicated Object Oriented Design Patterns, which are required to solve problems that Object Orientation introduces.

              Concurrent Programming Models

              Distinguishing Parallel Programming and Concurrent Programming

              Parallel Programming 

              Multiple-processor or multi-core programming

              Concurrent Programming 

              Multi-threaded programming

              Concurrent Programming Models

              • Threads and lock-based Synchronization
                • Java
              • Functional programming model 
                • Pure Functions with no side-effects + Immutable Data Structures
              • Actor based message passing
                • Scala
                • Erlang
                • Clojure
              • Channel based message passing
                • Go
                • Unix processes-pipes
              • STM (Software Transactional Memory) 
                • Clojure
              • Non-blocking I/O or asynchronous I/O
                • Callback Functions
                  • Node.JS: Event driven programming and Callback Functions.

              Programming Language Paradigms

              Programming Language Paradigms

              • Imperative, State (Memory) manipulation based, Assignment oriented Programming Language
                • C
              • Functional Programming Language
                • Haskell, Lisp (without setf)
              • Object Oriented Programming Language
                • Java, Smalltalk
              • Rule-based, Logic-based Programming Language
                • Prolog, Clips

              Most programming languages have hybrid philosophy.

              • Scala – Object Functional Programming Language
              • C++ – Imperative Object oriented Programming Language

              What is Machine Learning?

              One of the most sought-after skills of a modern Software Engineer or Computer Scientist is Machine Learning.

              So, what is Machine Learning?

              What we know about computers is that programmers write programs and computers follow the steps specified in programs. Wouldn’t it be wonderful if computers could learn and improve their performance with experience / feedback?

              That’s where Machine Learning comes in.

              Machine Learning algorithms enable computers learn from data and / or experience (experience, especially in the case of knowledge based learning) to improve their performance.

              How do computers do that?

              Let’s start with inductive learning.

              Traditional programming – writing functions that turn inputs to outputs.
              Inductive Learning – learning / inducing functions from inputs and outputs.


              There is another aspect to Machine Learning. In some problem domains, it’s just too hard to write a program that solves the problem. For example, it’s too hard to write a program that can recognize handwritten letters or turn speech to text.

              These are all application areas for Machine Learning.

              Example Applications

              • US Postal Service – recognition of handwritten postal code
              • Amazon product recommendation
              • Netflix movie recommendation
              • Netflix declared a $1 Million prize for the first program that can improve it’s movie recommendation algorithm by 10%. Alas! the prize has already been won! But there are quite a lot of money waiting to be won at Kaggle if you are interested[3]!
              • Facebook’s customized Newsfeed for each and every user
              • Gmail’s spam Email detection
              • Google’s Self driving car – object recognition
              • iPhone Siri – speech recognition


              Let’s try to define Machine Learning.

              “A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.”
              – Tom Mitchell [1].

              So, Machine Learning Agents are agents whose performance improve with experience.


              When do we use Machine Learning? 
              • Existence of Patterns.
                • Pattern: Repeated feature among a set of objects.
                • Existence of patterns means it could be possible for us to build a model that explains our data.
                • Sidenote: Mathematics is the study of patterns.
              • Hard to write an equation or algorithm that solves the problem.
              • Availability of Data [2]. 

              Machine Learning algorithms classified in accordance with the feedback available.

              • Supervised Learning
              • Learning / inducing a model / function from example input-output pairs.
              • Unsupervised Learning
              • Learning patterns from inputs when no output is supplied.
              • Reinforcement Learning
              • Learning how to behave from feedback given at the end of a sequence of steps.




              Knowledge Ontology for Machine Learning


              • Supervised Learning
                • Recommendation
                • Classification
                  • Bayesian Learning
                  • Neural Network
                    • Deep Learning
                  • Decision Tree
                  • Support Vector Machine
                  • Genetic Programming
                  • Ensemble Learning
                • Regression
              • Unsupervised Learning
                • Clustering
                • Finding Independent Features
              • Knowledge Based Learning
                • Once you have learned something, how do you keep adding to your knowledge?
                • Brings together Knowledge Representation and Machine Learning.
                  • Explanation Based Learning
                  • Relevance Based Learning
                  • Inductive Logic Programming
              • Statistical Learning
                • Learning Hidden Markov Models
              • Reinforcement Learning




              Android Application Architecture

              AndroidManifest.xml file holds all of the different components of an Android Application together. 

              The four main components of an Android Application – 

              • Activities 
              • Services 
              • Broadcast Receivers & 
              • Content Providers 

              expose themselves to others through Intent Filters in the AndroidManifest.xml file.


              Intent brings Web mindset to Mobile Application Development.

              Intent & Intent Filter are modeled after Web –

              • Categories
                • Describes where and how the Intent can be used. 
              • Actions
                • Web equivalent: GET, POST, PUT, etc.
              • URIs
                • Contains data that can be used as method arguments in the respective Activities, Services, Broadcast Receivers & Content Providers. 

              Android runtime evaluates the available Activities, Services, Broadcast Receivers & Content Providers and dispatches the Intent to the intended recipient as determined by the runtime.

              Android development is modular in architecture. Android developers build components (Activities, Services, Broadcast Receivers & Content Providers), use components developed for other applications and can let others use their components to build apps. 

              Java Development Skills

              Java Language & Standard Library

              • Language features
                • Class, Object; Garbage Collection; Inheritance, Polymorphism, Interface; Nested Type; Package; Assertion; Generics; Enum; Exception; Annotation; Reflections;
              • Data Manipulation API 
                • Math; Random number; BigDecimal; BigInteger; String, Character, Regular Expression; Primitive Wrapper; Array; Collections; XML Processing;
              • Development API 
                • Internationalization; Preferences; References; JMX; JNI. 
              • Systems and Network Programming API 
                • System; GUI, Swing, AWT; File; JDBC; Threading (Thread & Lock); Concurrency; Networking – Protocols; Servlet, JSP; Web Services; JMS. 

              Java Vital Techniques

              • Concurrency
              • Software Engineering: Maintainable, Replaceable Codebase, Modules
                • Design Patterns
                • Dependency Injection, Inversion Of Control
                • AOP 
                  • AspectJ
                • Modular Java 
                  • OSGi
                • Software Oriented Architecture (SOA)
              • Classfiles & Bytecodes
              • Performance Tuning

              Java Libraries & Frameworks

              • Spring 
                • Dependency Injection framework 
                • Distributed Application Development
              • Android 
                • Mobile Application Development
              • Play 
                • Highly concurrent & distributed Rapid Web Application Development Framework

              • Google Guice
                • Dependency Injection framework.
              • ActiveMQ
                • Message broker. JMS Client. 

              • Hadoop 
                • Mapreduce framework for distributed data processing.
                • Hive
                • Pig
                • HBase
              • Mahout
              • Hama
              • Zookeeper
              • Lucene

              Java Software Development Tools

              • Java Code Conventions
              • Software Development Processes
              • Automation: Productivity Increase
              • Testing
                • Unit Testing
                • Integration, Functional, Load, Performance Testing
              • Build 
                • Maven
              • Continuous Integration
                • Jenkins
              • Version Control
                • Git
              • Logging
                • SLF4J
              • Quality Metrics
              • Issue Management
                • Bugzilla
              • Technical Documentation Tools

              Polyglot Programming on JVM
              • Scala
              • Clojure

              Overview of (Artificially) Intelligent Agents

              Searching Agent

              In Artificial Intelligence, you don’t know the exact solution to the problem. If you knew, you would implement an algorithm to solve the problem and it wouldn’t be termed as Artificial Intelligence. So the approach is searching to solve problems.

              Problem Solving – Current State Goal State.

              Limitation: You provide the agent with a representation and the representation is static. The agent can only search.

              Knowledge Based Agent

              Knowledge based agents contain a representation of the world.

              Logic – a kind of representation for what is “true” in the world.

              Inference (if we know these and that are true, then what else are true?) – helps agents go beyond what you provided as representation.

              Example: If
              “Man is mortal” and
              “John is a man”
              are true in our world, then we can “infer” that
              “John is mortal”

              Other knowledge representation schemes besides all of the different forms of logic are available.

              Limitation: You can go only as far as “truth” (only true and false with nothing in between) deducible from your knowledge. Logic based agents are usually very inefficient.

              Planning Agent

              “Efficiently” “Searching” (Problem Solving) with “Knowledge”. Combines the approach of previous two agents.

              Probabilistic Agent

              All the facts describing the world are not just either “True” or “False”. There is uncertainty, randomness in the real world. Facts hold to a degree.

              Probabilistic agents use Probability Theory or other representations that incorporate randomness and uncertainty.

              Goal Based Agent -> Utility Based Agent -> Decision Theoretic Agent
              An agent must have a goal / set of goals – otherwise it’s behavior would be random. This is the concept behind goal based agent.

              Sometimes agents have conflicting goals. In cases like these, utility theory (“satisfaction from achieving each of the goals”) is employed.

              Decision theoretic agents combine utility theory (“how much satisfaction am I going to get from achieving this”) with probability theory (“what is the probability of achieving this”).

              Learning Agent

              The agents we considered thus far can only utilize information provided by the programmer. But to improve performance with experience, learning is required.

              Learning is also required in situations where the problem is so hard that human programmers can’t write the correct program on their own. So they write programs that either change parameters of a model or do logical reasoning to learn themselves.

              Agents That Communicate With The Real World

              Robots perceive, reason and act in the real world. Web-bots consume natural language documents on the web. Software like Siri communicate with us.

              Most of the problems in these domains have proven too hard to be solved by human programmers. Rather Machine Learning Algorithms are implemented. That is, ideas from Learning Agents are used. Ideas from all the above mentioned other agents are utilized as well.

              Artificial Intelligence: A Modern Approach

              Organization Of The Study And Application Of Algorithms

              Computational Abstractions

              • Control Abstractions
                • Loop 
                • Recursion
              • Data Abstractions 
                • Data Abstraction Components
                  • Structure of Data
                  • Operations on Data
                • Linear Data Abstractions 
                  • Array
                  • Stack 
                  • Queue
                  • Linked List 
                • Tabular Data Abstractions 
                  • Hashing
                • Recursive Data Abstractions
                  • Binary Search Tree 
                  • Red Black Tree
                  • Heap
                • Graph Abstraction
                  • Model: Objects with binary relation defined on pairs

              Computational Complexity

              • Time Complexity
              • Space Complexity  

                Algorithmic Paradigms

                • Dynamic Programming
                  • Recursively define solution to problem in terms of solution to limited number of subproblems.
                    • What could be the penultimate subproblems? (Work backwards.)
                    • Subproblems having same structure as the original problem, only being smaller in size. 
                    • Prove – defining solutions in terms of solutions to subproblems is optimal.
                  • Compute and store the results of subproblems in memory so that you don’t have to recompute them. Then use the stored results to compute solution to the problem. 
                • Divide & Conquer
                  • Divide the problem into subproblems (dividing up inputs into parts) and solve the subproblems recursively. 
                  • Combine the results of solutions of subproblems.
                • Greedy
                • Backtracking
                  • If you can define the space of all possible solutions, you can search the space for solutions systematically through backtracking. 
                  • In backtracking, you generate one element at a time towards the solution and backtrack whenever you meet a dead-end.  

                Application Domains

                Design algorithms using 

                • Domain Knowledge
                • Computational Abstractions & Algorithmic Paradigms 

                Number Theory

                • Domain Knowledge: Prime, GCD etc.
                • Computational Abstractions & Algorithmic Paradigms: Loop, Recursion etc.


                • Domain Knowledge: Binomial Co-efficient, etc.
                • Computational Abstractions & Algorithmic Paradigms: Loop, Table, Dynamic Programming etc.

                String Processing

                Linear Programming

                Matrix Algorithms

                Computational Geometry

                • Domain Knowledge: Properties of geometric objects
                • Computational Abstractions & Algorithmic Paradigms: Stack, etc.

                Polynomials & Fast Fourier Transform