Open Terminal from Xcode

I love Xcode as an IDE for macOS and iOS development. But it has its own set of limitations. One feature I miss a lot is Opening a Terminal window from the Xcode into the same directory of the project. This will save lots of time.

Every time you want to run a git command or cocoapods or say any xcode build command – Opening a Terminal manually and changing the directory to the project directory takes at the least 30 seconds to a minute. Now what if I say you can do this

Now, What if I say you can open a Terminal window and get to the project directory  in 1 second or say with a shortcut key?

YES! One shortcut.

This is how you do it. It’s a one time setup.

1. Create a 2 line shell script and give the file execute permission.
2. Go to Xcode Preferences.
3. Add a Behavior in Xcode. Name it and give a shortcut key.
4. On the right side details pane check the Run option.
5. From the adjacent drop-down menu choose the script you just saved in step 1.

Here’s the video on how to do it.

Script:
#!/bin/bash
open -a Terminal "`pwd`"

Command to give execute permission:
chmod +x /path/to/the/open_terminal.sh

If you are lazy like me here’s the gist, download and use it: https://gist.github.com/itsdamslife/9532d757676b1f3c9b25f3959128367c

Hope this is helpful.

Happy coding 😉

inspiration courtesy: The in-built Terminal of Visual Studio Code by Microsoft


Damodar Shenoy's DEV Profile

Advertisements

Deep copy and Shallow Copy

This is an important concept of computer science. You may have heard it very less in your day-to-day work life but your work will directly or indirectly relate to this one of the main concept of memory management. Let’s dive into this.

Here is scenario – Assume you have a team of 5 members. You have created a document on Google Drive and shared the link to the document with your team members.

Now how the doc is used / consumed is upto the members. Primarily there are two ways:

  1. One is : Using the online version directly to read/update or if someone updates you get the latest update directly. One can see the changes live.
  2. The other way is: Download a copy to your local system and use it as per your wish, manipulate it update it without altering the original copy which is on the cloud.

Thats it. If you know the difference between the 2 above,You got the concept! The first one is Shallow copy of the document and the second one is Deep copy of the document.

Now using this analogy let me explain you the memory management concepts of Objective-C and Swift.

  • strong : Members who have doc added to their own drive. Even if original is deleted the doc is not deleted. The reference link still points to the doc
  • weak : Members who have access to the doc will be informed upon deletion of the doc. Now the reference link will be invalid. It will point to nil.
  • assign : Members who have access to the doc will NOT be informed upon deletion of the doc. Now the reference link will be invalid. App crashes if the link is accessed.
  • copy : Members download copy of the doc to their own system. Does not effect if either of them are modified or deleted. Takes up additional memory unlike the above 3 which are referenced to same memory location. Mutable copy is when document is downloaded with RW permissions.

The 4 statements above may or maynot hold good for Google drive but only used to explain the concept.

Pros & Cons:

Shallow copy

  • Doc link which is stored in the cloud
  • Owner and admins is the strong reference
  • Non admins will have weak reference
  • Changes to the document will be notified to every member

Deep copy

  • Document downloaded to local system
  • Consumes additional storage
  • If some one changes in the cloud does not effect your local system
  • Whatever you change locally does not effect cloud version

I made up this analogy because I found it easier to link both the concepts for understanding. Let me know if you find this difficult or missing. Please share your comments below.

happyCoding();


Dam's DEV Profile

Obj-C — Swift — Obj-C

This is one of the rare scenarios one might get into, but the problem and its solution are unique and the simplest one here.

  • Have you come across a scenario where you felt the need for an additional method in a class inside a framework (one of the Pods you added) to achieve your work?
  • Is the library implemented in Objective-C?
  • Is your legacy code in Objective-C and now you are strategically moving to Swift?

Today at work my friend, Vinodh, asked me this:

“I have a pod framework which is in Objective-C, I need to add a functionality but needs to be used in Obj-C for now and may be used in Swift file in future. What is the best way to do this?

Let us say we have a class called Person inside one of your pod frameworks. This Person class has name, age and gender as properties, with a function to format the name.

// Objective-C header file of Person class
#import 

typedef enum : NSUInteger {
    male,
    female
} Gender;

@interface Person : NSObject

@property (nonatomic, strong) NSString *name;
@property (nonatomic, strong) Gender *gender;
@property (nonatomic, strong) NSUInteger *age;

- (NSString*)formattedName;

@end

// Objective-C Implementation of Person class
@implementation Person

- (NSString*)formattedName
{
    return [NSString stringWithFormat:"This is %@",self.name];
}

@end

When the formattedTitle method is called on a person object with value for name property ‘Vinodh’ it would print like “This is Vinodh”.

Now we need to extend this Person class with another method say a new format which tells the age along with the name.

In classic Objective-C style it would be adding a category to Person class, Importing this category wherever you need this new method. This would have been the best way before Swift was introduced.

But there is a disadvantage if new developer join unitl and unless (s)he imports the category header, code completion will not show the new method. Probably the new developer will end up writing the same method creating a new category again. This is a problem.

Swift to rescue. Do the following:

  • Create a Person class extension and write the needed method
  • Now create a protocol and declare the method signature
  • Now prefix the protocol with @objc to make this available in Obj-C files

Here’s how you do it.

@objc protocol Formats {
    func getFormattedName(with ageHidden: Boolean) -> String
}

extension Person: Formats {
    func formattedName(with ageHidden: Boolean) -> String {
        let formattedString: String = ageHidden ? "This is \(self.name)" : "This is \(self.name) aged \(self.age) years."
        return formattedString
    }
}

Now wherever you type [personObject form… in Obj-C or in personObject.form… in Swift the code complete will show you both the methods one Person class another from the extension we added.

Love to hear more stories from your side. Please do share in comments.

Happy Coding!

Swift meetup

After a long time attended a meetup. And this was on the topic which I work on day to day – Swift programming language.

The meetup overall was good. Got to learn couple of new things – DispatchGroups, Swift Runtime and the thing that we can have our own Swift’s virtual environment just like virtualenv in Python, for swift its called virtualswift.

The most useful talk for me was on measuring performance in swift by Mayur Dhaka in which I can use immediately is DispatchGroups.

DispatchGroup primarily avoids the code shifting to right while using nested blocks like completion handlers.

From what I understood is DispatchGroups are the thing which can be used to group a logical set of background operations into one unit. It has very few APIs. According to Apple :

DispatchGroup().enter() – to indicate the block has entered the group.

DispatchGroup().leave() – to indicate the block in the group has completed.

DispatchGroup().notify(...) – to schedule a block or a work item to be submitted to a queue when a group of previously submitted block objects have completed.

DispatchGroup().wait(...) – waits synchronously for the previously submitted work to complete.

Basically DispatchGroup is to synchronize and track a set of tasks which are logically grouped and executed according to your requirements.

Hope this gist will help you get to know something new and explore more if interested.

swift-small

The 5 minute series

As mentioned in my previous blogpost the first among my targets this year is to start a 5 minute series to get introduced to anything. With this post I am listing down my initial set of topics which I will be writing on. This list will grow periodically and also will be updated with the links to each 5 minute series.

Following are the topics for which I am planning to do 5 minute introductions this year

I will be adding more to this list I finish each one.

This is the first time I am doing a 5 minute series. So your comments and suggestions are very very important to me. All criticism is taken up for improvement of such tutorials.

Hola 2018!

Hellos fellows!!

Its been a while now wanting to write a blog. I thought of writing at least one blog per week in 2018 amounting to at least 52 blogs at the end of the year if am consistent enough.

Following are the things I want to be consistent in 2018.

  • The <Anything> in 5 minutes series
  • Simple tips and tricks of technology
  • Go live on YouTube programming anything
  • 50+ blog posts in 2018
  • Read a book a month – 12 books this year

Apart from these publicly visible things I will be going to do few side projects to learn something new in a field apart from my work. Learn about Machine learning, create couple of android apps. Build a wunderlist clone as its fortunately or unfortunately acquired by microsoft.

Do yoga and practice guitar are 2 more things I forgot.

That’s pretty huge for a lazy me. But looking at my first 2 weeks of 2018 I am pretty much consistent, I will do this. I am gonna achieve this for sure.

Here is my first blog post of 2018.

Have a rocking year. \m/

Compiler directives @ objective-C 2.0

Here are the list of directives in Objective-C 2.0. Let me know if anything is missing.

// directives used in class declaration
@interface @public @package @protected @private @property @end

// directives used in class implementation
@implementation @synthesize @dynamic @end

// creating a string object
@”string”

// for forward declaration
@class

// similar to function pointers
@selector()

// used for method declaration mainly for delegation purpose
@protocol @required @optional @end

// to assure thread safety
@synchronized

// handling memory issues (useful in ARC enabled apps)
@autoreleasepool

// throwing and handling exceptions
@throw @try @catch @finally

// type encoding (Apple docs)
@encode

// aliasing an existing class name to a new one (useful in refactoring)
@compatibility_alias

Happy coding!