Summary:Definitely worth considering
I got back to this one after a while. First time I have watched this material, I was amazed. Now, I have cooled down a little bit, and I have slightly different perspective. Today, I am not only interested in git, but I actually use it. That’s why I can see more drawbacks then few months ago. But still, I think this is good tutorial.
When it comes to good sides of the material, for sure you have to count in the way it is presented. The point here is that you get the gentle introduction and explanation of all basic concepts related to git. All the concepts that can be presented with samples, are shown on screen as they are described. It makes them super easy to follow.
Did you know that “.git” is a literally all you need to have an access to your repository? If not, you will learn that, as well as details related to branches, tags, and HEAD (refs) management.
If you use SVN you probably know that working with branches might be a challenge due to the issues related to time consumption and merging related issues. The tendency, in SVN based projects, is to skip branching at all and putting all the codes into trunk. This is quite common practice. On the other hand, git offers cheap branching. And this topic is discussed in this video quite through. On the other hand, pay attention to that part as it is very important and for the beginners it might be confusing as branching concept is slightly different here from SVN. You should really watch this part few times, in case it is required, to get it fully understood.
And one remark. Try to follow the tutorial with your local git repository.
Apart from that you will get of course remarks on tagging and merging. Which are most common tasks to be done with the versioning system.
Pros:
- covers all the basics of the git that will let you work with git with correct understanding of all basic concepts
- covers branching, merging, tagging which are most common things you will probably perform during development
- the whole session is based on a tutorial that starts with creation of the repository and then is extended with further topics – if you follow it from start to the end it is hard to get lost
Drawbacks:
- audio and video are out of sync at some point, and it takes time to get used to it
- some concepts – especially the introduction – are little bit too long
- the way interaction between Tim and Matthew (in terminals) is done is OK – two separate terminal screens, where you can see what is happening. But, believe me, in Mastering Advanced GIT they have excelled even more. Trust me!
- some people mention that you can find similar material on the youtube as well. And that’s true. You can save some money here. But I would argue with that approach. The content, here, is made strictly as tutorial session with very well structured flow of the material. So, you have to decide
- lack of the syllabus. It would be great to have it for download so you can refer to in on fly
O’Reilly: http://shop.oreilly.com/product/0636920017462.do
Safari Books Online: http://my.safaribooksonline.com/9781449304737?portal=oreilly&cid=orm-cat-readnow-9781449304737
December 4th, 2013 in
main entries |
No Comments
If you are looking for the JavaScript environment
1. JavaScript interpreter in OSX
/System/Library/Frameworks/JavaScriptCore.framework/Resources/jsc
And you can simply call the following code
// test.js
var test = 1
print('Hello ' + test)
very simply by calling
/System/Library/Frameworks/JavaScriptCore.framework/Resources/jsc test.js
2. Install NetBeans :)
In NetBeans 4, create HTML5 project, create JavaScript file, create HTML file that uses this file and you have full debugging support.
December 3rd, 2013 in
main entries |
No Comments
Yes! This article is about how to debug code using iPad mini.
This note was added after publishing the post.
I was strongly against iPads as anything else apart from advanced Angry Birds playing machine. Well, maybe e-mail reader and web browsing machine. But that’s it. No more should be possible there – that’s what I thought. Recently, I had half day of totally spare time. Nothing to do, poor network connection. Disaster!! However, I had my iPad with me, and I had one thing over my head. How to debug JNI code efficiently with ssh. Eventually, it turned out that I can do everything using 9″ screen and bluetooth keyboard. Read on.
This post was prepared entirelly using only iPad and ssh sessions (No cheating! I promise). Yeap, this is pssible to do actual dvelopment using iPad. Below, you can find the list of software/hardware used for this purpose:
software:
- WriteRoom – for creating post content
- Prompt – for accessing remote machine
- Safari – for posting the content into WordPress
- tmux – for better living with ssh via Prompt
- screen – for preventing loosing ssh session interrupted by Prompt
- vi – well, do you have anything better here?
- jdb – debugging Java with good old CLI
- gdb – debugging jdb with good old CLI
- java – for compiling and running Java code
hardware:
- iPad mini (without retina :) )
- Apple’s aluminium bluetooth keyboard (you can survive with on-screen keyboard – this was the only “cheat” from my side)
task:
- debug Java code that uses JNI
- debug native code called via JNI
solution:
- start Java VM i debug mode and listening on a given port
- start jdb and connect to JVM
- start gdb and connect to JVM
example code:
Example code is a very simple Java application that calls native procedure written in C. I will not go into details here when it comes to JNI. All you get here is a simple JNI code that will be used during the session. So, let’s go into details.
First, create some directory where you can store all the codes and then create following files inside the directory
/* Simple.h */
#include "jni.h"
JNIEXPORT void JNICALL Java_Simple_displayMessage(JNIEnv *env, jobject obj);
/* Simple.c */
#include
#include "Simple.h"
JNIEXPORT void JNICALL Java_Simple_displayMessage(JNIEnv *env, jobject obj) {
printf("Hello from JNI!\n");
}
/* Simple.java */
class Simple {
public native void displayMessage();
static {
System.loadLibrary("Simple");
}
}
/* Main.java */
public class Main {
public static void main(String[] args) {
System.out.println("library: " + System.getProperty("java.library.path"));
Simple simple = new Simple();
simple.displayMessage();
}
}
After files are ready, you can compile and execute the whole scenario using following command:
export JAVA_HOME=/wherever_your_java_path_is/
$JAVA_HOME/bin/javac -g *.java
$JAVA_HOME/bin/javah -jni Simple
cc -g -shared -fpic -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux \
Simple.c -o libSimple.so
export LD_LIBRARY_PATH=`pwd`:$LD_LIBRARY_PATH
$JAVA_HOME/bin/java Main
After executing the code, you should see message
"Hello from JNI!"
This is the result of native code. Now, what we will do here is going into native code using gdb and at the same time debugging the Java code from jdb.
First, let’s start JVM process and susspend it – we will wait for the connection from the jdb. This way, application will be in pending state and Main.class will not be executed – yet. To do so, call java following way
java -agentlib:jdwp=transport=dt_socket,\
server=y,suspend=y,address=32887 \
-Djava.library.path=.:"$LD_LIBRARY_PATH" \
-cp . Main
You will see following message
Listening for transport dt_socket at address: 32887
And that’s how will terminal look like
Note the value “32887″ – we will need it. This is the port number we will connect through from the jdb to JVM running Main.class.
Now, go to the second terminal and start jdb. If you want to have access to sources, use -sourcepath argument. Basically, all you have to do is to call
jdb -sourcepath . -attach 32887
Afte calling it, you will see jdb being attached to the JVM
shell>jdb -sourcepath . -attach 32887
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
Initializing jdb ...
>
VM Started: No frames on the current call stack
main[1]
You should see something like this
And now, we are ready to debuging. First, let’s make sure that we will brake in the code. Inside jdb type in:
stop in Main.main
run
After we hit the breakpoint, list the code using “list” command. If you take a look at the Simple.java code, you can see that during creation of the class static part of the class will load the library (native code). Let’s break after this line. We can do this following way
stop at Main:5
continue
What you should see will look following way
shell>jdb -sourcepath . -attach 32887
shell>jdb -sourcepath . -attach 32887
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
Initializing jdb ...
>
VM Started: No frames on the current call stack
main[1] stop in Main.main
Deferring breakpoint Main.main.
It will be set after the class is loaded.
main[1] run
> Set deferred breakpoint Main.main
Breakpoint hit: "thread=main", Main.main(), line=4 bci=0
4 Simple simple = new Simple();
main[1] list
1 /* Main.java */
2 public class Main {
3 public static void main(String[] args) {
4 => Simple simple = new Simple();
5 simple.displayMessage();
6 }
7 }
8
main[1] stop at Main:5
Set breakpoint Main:5
main[1] cont
>
Breakpoint hit: "thread=main", Main.main(), line=5 bci=8
5 simple.displayMessage();
main[1]
Inside Prompt you will something like this:
At this point we are just before calling the native code. This is the right time to unleash gdb. In yet another terminal window we will look for executed JVM and we will attach to the correct one
shell>jdb -sourcepath . -attach 32887
shell>jps
14586 TTY
14531 Main
15161 Jps
shell>gdb /proc/14531/exe 14531
...
...
(gdb)
Now, we can take a look whether library is already loaded
info shared
You should see the entry that contains library that we use:
...
...
0x00002b8ba2864540 0x00002b8ba2864678 Yes
/pfs/home/michalo/jni
/libSimple.so
(*): Shared library is missing debugging information.
(gdb)
So, let’s break in the native code
(gdb) info shared
From To Syms Read Shared Object Library
...
...
...
0x00002b9b18000540 0x00002b9b18000678 Yes /pfs/home/michalo/jni
/libSimple.so
(*): Shared library is missing debugging information.
(gdb) break Java_Simple_displayMessage
Breakpoint 1 at 0x2b9b18000624: file Simple.c, line 5.
(gdb) cont
Continuing.
At this point we are contiuing the JVM’s code. Let’s get back to jdb and continue as well. As you will see, nothing happens. The point here is that we have hit the breakpoint inside gdb
[Switching to Thread 0x2b9b08e86700 (LWP 16022)]
Breakpoint 1, Java_Simple_displayMessage (env=0x401181d0,
obj=0x2b9b08e85978) at Simple.c:5
5 printf("Hello from JNI!\n");
(gdb) list
1 /* Simple.c */
2 #include
3 #include "Simple.h"
4 JNIEXPORT void JNICALL Java_Simple_displayMessage(JNIEnv *env, job
ject obj) {
5 printf("Hello from JNI!\n");
6 }
7
(gdb)
[1] 0:java
And now, we can debug native code. When we execute continue inside gdb, jdb will continue as well, and the application will eventually finish.
shell>jdb -sourcepath . -attach 32887
shell>java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=3
2887 -Djava.library.path=.:"$LD_LIBRARY_PATH" -cp . Main
Listening for transport dt_socket at address: 32887
Hello from JNI!
shell>
And that’s pretty much it. So, just to conclude. In order to debug JNI and JVM at the same time:
- start JVM in debug mode (listening for the JPA connections)
- start jdb and debug the Java code
- start gdb and attach to JVM in order to get into native code
And for the summary related to the above scenario, here are few remarks on the feelings related to the whole proceess:
- I miss Cmd-Tab, Cmd-` on the iPad. Clicking Home button is so frustrating (especially when you use external keyboard)
- Prompt is dropping connections from time to time. This might be frustrating if you lose part of the work. Use screen to prevent loosing your nerves.
- Prompt will missbehave with selecting multiple lines. It simply gets lost from time to time and created arbitrary text selections when you play with the range of selected text
- Prompt will not provide you with the shell history :(
- Prompt will produce occasionally some artifacts on the screen (e.g. text from the other tmux session – which is strange)
- WriteRoom has this strange issue that attaching external keyboard leaves a bar with some functional keys and you will not see your text as it goes beyound this bar. To avoid this issue, go to projects, and choose full-screen mode (right bottom corner)
- Mouse – maybe it will be possible at some point to use mouse on iPad. Selecting text areas with touching the screen is a nightmare. Especially, when you are on external keyboard.
Anyway, I must admit that we got to the point where iPad based developement is possible and perfectly doable. Next time, I will try to do the same with Nexus 7 and compare my experience. But still, it took much more time to prepare this text comparing to what I would have to spent using OS X. And, I still have no idea how to put images into post :)
In fact, this part turned out to be super easy. WordPress simply allows you to pick images from the camera roll. And with iOS 7 it is just a matter of few clicks to make a simple image processing
Note, you can avoid using three separate terminal sessions by using gdb with java by calling it following way
export LD_LIBRARY_PATH=.:"$LD_LIBRARY_PATH"
gdb java
set args -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=32887 -cp . Main
run
This way, you will be debugging JVM the same way as before.
Summary:Definitely worth the attention
Database Design and Relation Theory is targeted on database professionals. It means that you have to have some database related background already. If you don’t, start with something else before you get into this one – for sure! Otherwise you might get lost in definitions and all the concepts presented in the seminar.
Video training is based on the book with the same title. So, you can choose either the book itself, or this companion material. By the way, together with the Video training you get all the slides as well. This way it is super easy to follow the seminar in case you want to focus on some particular slide. And you always have the possibility to refresh your memory quickly in case there are references to topics that have been already discussed.
The way material is presented is very concise and formal. You actually take a part in an academic lecture discussing Database Design. It will require lots of attention from your side and your brain will have to do work here. There is no chance for getting an easy path through it, unless you are already familiar with all the topics. You need to poses basic mathematical skills in terms of algebra of sets, basic knowledge of logic, and you should be familiar (maybe more suitable here would be comfortable) with the mathematical approach to proving theorems. It doesn’t mean you will have to do this. But if you know what is it all about, it will be easier for you to follow the contents of the material.
As for the time. Don’t assume you will spent the same amount of time as specified in the description. I’d easily multiply it by two. The point here is that you will definitely need to go through the slides carefully (from time to time) to get the concepts fully understood. Sometimes you will probably jump back to what you have already seen just to recall some concepts and to make sure you are on the right track with you way of thinking.
Even though this one is not an easy go, I’d definitely suggest it to people who are involved in database design. You might get surprised with some examples that are really counterintuitive. And (I must admit here) I was told some ideas in the past that were wrong by definition. Here, I got them explained once again – this time, the correct way.
When it comes to the price, I must admit this one is quite costly. So, depending on your needs you might rather subscribe to safari books online instead. On the other hand, if you buy the video itself, you can transfer it to your iPad or Nexus with ease.
O’Reilly (print): http://shop.oreilly.com/product/0636920025900.do
Safari Books Online: http://my.safaribooksonline.com/9781449336370?portal=oreilly&cid=orm-cat-readnow-9781449336370
November 15th, 2013 in
main entries |
No Comments
Recently, I have purchased Virus Barer x6 as a part of StackSocial bundle – if I remember correctly. And this was the spark for the quite time consuming research related to viruses, malware and all that stuff in the OS X environment.
The point is, that architecture of the OS X is generally safe. You know, all that Sandboxing, running apps as user, making sure that nothing can happen under the hood without your knowledge. But the fact is that running apps as root is not that hard to do. You simply ask user for the password, and I am sure they will give it to you (take a look at all these anti virus apps, they all ask you for the password during installation). The fact is, that these apps add various daemons, kernel extensions, etc. to your system. Of course, this is OK, because you know what you are doing. However, the point is that viruses, malware and all that nasty stuff can make the same thing. Apps can simple ask you for the root password, and I am pretty sure, you will give it gently. So, basically, it is safe to assume that viruses, backdoors and various malware is possible in OS X.
On the other hand, protecting your precious is not that simple. I have tested four different packages for the security purposes. These were: Virus Barer x6 (commercial and paid), Avast! (commercial but free), Sophos (commercial but free), ClamAV (open source and free). Of course you have dozen of AV applications but I had neither time nor will to test all of them. The picks above were simple. I had either licence already, or these were free software.
So, what are my feelings here? I am pretty sure that you can say bye-bye to all live scanners that instantly check you machine in order to catch all the evil things from the internet. The fact is that gain is not worth the loss. My experience were as follows.
- system startup got much longer
- everything got slower
- e-mail and web browsing experience turned out to be a nightmare (in worst case I was not able to do anything after booting for almost 5 minutes).
All the commercial products were simply busy occupying my CPU almost all the time. This was not acceptable. The last choice was ClamAV. This open source engine is probably the worst case in terms of user interface experience but it has few advantages.
- it is free
- you can run it in your spare time (e.g. during night) and you don’t loose your CPU power during day to day work
You will probably ask whether something like this can be worth your trust. Well, it depends where you put your trust in. If the UNIX world is something worth your credit, then you will probably appreciate that ClamAV is a solution present in Linux distributions for some time already.
If you think that people at Apple know what they are doing, take a look below. This is the screen shoot from OS X Server.
As you can see, there is a ClamAV installed by default in the OS X server. It should ring a bell to you.
Now, getting back to my case. I have eventually compiled and updated my version of ClamAV and that’s my solution for the viruses so far. Let’s hope regular checking my machine will be enough. And I have to say bye, bye to all real time scanners as they simply consume too much precious time of my CPUs.
October 23rd, 2013 in
main entries |
No Comments
