A Git tutorial with example and demo.
YouTube Videos
Day 1: https://www.youtube.com/watch?v=XBreuLi79bk
Day 2: https://www.youtube.com/watch?v=5e6i3r5Vz34
A Git tutorial with example and demo.
YouTube Videos
Day 1: https://www.youtube.com/watch?v=XBreuLi79bk
Day 2: https://www.youtube.com/watch?v=5e6i3r5Vz34
This presentation is a feedback of how I wrote a simple lock profiler on the JVM, including architectural overview, limits of the current approach and roadmap for future versions
Introduction: This session discusses simple guidelines that can help develop reliable and high performing parallelism friendly applications in Java. It introduces some of the best practices that can be adopted in Concurrent programming in Java. The session also briefly explains various techniques used by the Java Virtual Machine to optimize synchronization.
Background: Over the years, there has been significant amount of work to make Java support concurrency with less overhead. With the advent of multi-cores, Parallelism is very essential to increase the Application throughput. Parallelism introduces atomicity and visibility issues. From Java 5 onwards, significant improvements like java.util.concurrency, Latches, Barriers are introduced to support Concurrency.
Considerable improvements have also been done at the Virtual Machine level to optimize synchronizations.
Session Agenda: The Session focuses on the “What?Why?How? of Concurrency” in java. It briefly describes the synchronizing features available in Java. A common set of pitfalls faced in Concurrent programming and methods to over come these pitfalls are also introduced. Usage of concurrent collections, Latches and Barriers is demonstrated. Much attention has been given to optimize lock management and synchronization in Java virtual machine. Features like biased locking, lock coarsening, lock elision by escape analysis and adaptive spin locking aim at this optimization. The Session explains each of these features.
Summary: The session describes some of the best practices in developing bug-free concurrent applications. Common pitfalls encountered in concurrent design and methods to avoid such pitfalls are also described.
Presentation describes basic concepts of thread pool such as:
- interacting with queues,
- using pools from Executors class,
- task rejecting
- using ThreadFactory for thread creating
- Future and Callable interfaces,
- basic API
- possibilities for extending
1. A brief introduction of Git (SVN, CVCS, DVCS etc.)
2. Git/TortoiseGit/msysgit installations
3. A complete guide of Git operations
4. The Branches and HEAD
5. Remote and local repository
6. Rebase and submodules etc.
7. Some Skills and Experience
A simple introduction for basic use of git and git hub.
Since I'm a rookie to Git, If there is anything wrong, please contact me.
Hope you'll enjoy it.