Forem: DSC CIET

Creating Hello World App in Flutter

Neeraj Gupta — Sat, 06 Mar 2021 11:19:55 +0000

Hey guys, so now from the past month I had now been exploring Google's Flutter and it's kind of interesting. I mean native is good but in case you want more complex UI in less amount of time with huge support then Flutter seems to be a good choice although Facebook's React Native is also there But I haven't explored that much yet.

So, today's let's see how we can create a simple Hello World app in Flutter using Dart language.

For DART checkout their official - https://dart.dev/guides
For Flutter Setup - https://flutter.dev/docs/get-started/install

main.dart

import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: SafeArea(
        child: Scaffold(
          body: Center(
            child: Text("Hello World"),
          ),
        ),
      ),
    );
  }
}

In flutter everything is in form of widgets(pre made components by Flutter team or other developers).

We get a huge number of pre made widgets in material package that's why we included material.dart file in order to use these widgets by flutter team.
We need to define a main function which is starting point of our app.
Stateless widgets in which every value defined remains constant throughout the lifecycle of app. Stateless Widget are used to make screens where data is gonna remain same and will not change on user interaction.
We need to provide name of class (here MyApp) which extends Stateless widget which means it is child of Stateless Widget and it inherits properties and methods from Stateless widget.
Then we define a build function and pass a context inside it which reference to current class and we return a widget from this build function as we define that it will return Widget.
First widget we see is MaterialApp widget which provides material layout provided by Google to our app.
Next comes Safe Area and Scaffold Widget which is defined in home property of MaterialApp and Scaffold widget provides a blank screen for our app with white background.Safe Area brings your app's content whithin safe area that is defined for your device screen.
In Scaffold's body we used Center widget and it centers it's child to center of screen and we define a Text widget inside Center widget. So, we are saying to center text defined here.

For more info on these widgets checkout here -
MaterialApp - https://api.flutter.dev/flutter/material/MaterialApp-class.html
SafeArea - https://api.flutter.dev/flutter/widgets/SafeArea-class.html
Scaffold - https://api.flutter.dev/flutter/material/Scaffold-class.html
Center - https://api.flutter.dev/flutter/widgets/Center-class.html
Text - https://api.flutter.dev/flutter/dart-html/Text-class.html

Here you can check all the properties and methods available under this particular widget.

Now run your app using

flutter run

App will look like this

Hope, you get a basic idea to get started with first application in Flutter.

Sets in Swift

Neeraj Gupta — Sat, 02 Jan 2021 13:31:08 +0000

Brief Introduction About Swift

Swift is a language developed by Apple which is made using modern approach, include safety features and software design patterns. As the name suggests swift is fast, safe and easy to use. It is basically made a replacement for c-based family(C, C++ and Objective-C). It can be used to make apps and can be also used for cloud services and it is among the fastest growing languages.

Sets in Swift

Sets are unordered collections of unique values. Dictionaries are unordered collections of key-value associations. Sets are mainly subset(part) of Dictionaries. In Sets every value defined is unique and they store value by hashing so values are not stored in a fixed order and their order can vary while accessing.

Syntax to Define Sets

var setName : Set<DataType> = [values]

Here the data type passed need to be of Hashable type.

Hashing

Hashing means generating a unique id for every value .

Code Example

var SamsungSmartphone : Set<String> = ["Android", "Camera" , "Samsung Pay"] //hashing
var AppleIPhone : [String] = ["iOS" , "Camera" , "Apple Pay"]

print(SamsungSmartphone) // ["Camera", "Android", "Samsung Pay"]
print(AppleIPhone) // ["iOS", "Camera", "Apple Pay"]

**Note: In your case order of printing can differ as sets are unordered due to hashing process.

Inbuilt Functions

//Below are two sets with similarities and some differences in both sets
var SamsungSmartphone : Set<String> = ["Android", "Camera" , "Samsung Pay"] //hashing
var AppleIPhone : [String] = ["iOS" , "Camera" , "Apple Pay"]

print(SamsungSmartphone)
print(AppleIPhone)

//Inbuilt Functions

// Intersection returns the element common in Both sets
print(SamsungSmartphone.intersection(AppleIPhone)) // ["Camera"]

// symmetricDifference returns all the elements that are not common in both sets
print(SamsungSmartphone.symmetricDifference(AppleIPhone)) // ["Samsung Pay", "Apple Pay", "iOS", "Android"]

// union returns all the elements in both sets
print(SamsungSmartphone.union(AppleIPhone)) // ["Android", "Samsung Pay", "Apple Pay", "Camera", "iOS"]

// Returns the elements in first set that do not match second set
print(SamsungSmartphone.subtracting(AppleIPhone)) // ["Android", "Samsung Pay"]

// Inserting Value in Set
SamsungSmartphone.insert("Samsung Watch")

// Finding Values in Set
print(SamsungSmartphone.contains("Android")) //true
print(SamsungSmartphone.contains("Andoid")) // false

Custom Sets

Now Let's see how we can create custom sets.

struct Smartphone : Hashable {
    let name : String
    let model : String
}

let smartphoneObj : Set<Smartphone> = [Smartphone(name: "Apple", model: "iPhone"), Smartphone(name: "Samsung", model: "S9")]
for smartphone in smartphoneObj {
    print(smartphone.hashValue)
}


//Output:-
// Some random id
//Some random id

Here, we created struct and declare some properties in it and note here we are conforming it to protocol Hashable so that when making object from it we can utilize the functionalities of Sets.

Here, output will be 2 random id's as we are passing different parameters in set parameters and we know every element is unique in Sets. So, what if we give both elements same values as parameters? Will it print 2 random id's or a single random id?

Let' see

struct Smartphone : Hashable {
    let name : String
    let model : String
}

let smartphoneObj : Set<Smartphone> = [Smartphone(name: "Apple", model: "iPhone"), Smartphone(name: "Apple", model: "iPhone")]
for smartphone in smartphoneObj {
    print(smartphone.hashValue)
}

//Output :- 
//Some random id

It wil print one single id. Why? Because it maintains uniqueness and it will generate one hashValue corresponding to both means it will map both of them to same hash id as to maintain uniqueness.

This was all about sets in swift. Hope, this helped. Meet you guys in next post.

API Parsing Using Decodable Protocol in Swift

Neeraj Gupta — Tue, 22 Dec 2020 15:27:04 +0000

Brief Introduction About Swift

Steps involved in Swift API Parsing

Make a URL.
Make URL Session
Make Data Task
Resume Data Task

Code Example

So, here for example we will be using kanye.rest API.

// Created by Neeraj Gupta
// Xcode Playground

//
//  ViewController.swift
//  Weather
//
//  Created by Neeraj Gupta on 04/12/20.
//

import UIKit
import PlaygroundSupport

//This line of code tells Xcode to not Kill the process and continue even after reching end of code
PlaygroundPage.current.needsIndefiniteExecution = true

//We need to define a Model for keys which we want to extract from API.
// We will discuss about decodable process later in this lesson
struct Model : Decodable {
//    Here my data contains only a single string so we need to define a single key which is of type string and Note the name of key defined should be same as that in API.
    let quote : String
}

//Storing the url for API in a constant named "url", can be different in your case.
let url : String = "https://api.kanye.rest/"
//Calling function named fetchData by passing this url as argument
fetchData(url : url)

// Here fetchData is taking that url String as parameter
func fetchData(url : String) {
//    Let's proceed with step 1 that is make URL and here we are using optional binding as the URL we get is "optional" and we need to check if it's not returning "nil"
    if let sessionURL = URL(string : url) {
//        Let's see Step 2 that is making session for URL. URLSession(An object that coordinates a group of related, network data-transfer tasks.) as per documentation. Parameter passed "configuration is "A copy of the configuration object for this session."
        let session = URLSession(configuration: .default)
//        Let's proceed with Step 3 that is making Data Task(Creates a task that retrieves the contents of the specified URL, then calls a handler upon completion) as per documentation. We use a method dataTask(func dataTask(with: URL, completionHandler: (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask) from URLSession Object. In completion handler press enter and a closure will appear as below and enter name of parameter in all 3 fields.
        let dataTask = session.dataTask(with: sessionURL) {(data, response, error) in
//            The data we get here is optional so we need to optionally bind it to check for "nil"
            if let safeData = data {
//                Now we have a encoded data and we need to parse or decode it so we make custom function named "JSONParse" and pass data in it
                if let parsedData = JSONParse(data : safeData) {
//                    The data we are getting is optional so we need to optional bind it and check for "nil" and if not nill print key from object received
                    print(parsedData.quote)
                }

            }
        }
//        Here we do Step 4 that is resume Data Task. This is used to start the Data Task we just created
        dataTask.resume()
    }
}

//Here is "JSONParse", Our custom method for decoding Data. We pass data of type "Data" as parameter and we are expecting to get Data of type Model(Our Custom Struct) from it. Data we are receiving is optional as we are telling swift by adding "?" to it.
func JSONParse(data : Data) -> Model? {
//    Let's make an instance of JSON Decoder class.
    let decoder = JSONDecoder()
//    We have to use do catch block as "decode" method can throw an error and we need to pass data type we want to decode as as first paramter and the data which we want to decode as second parameter
    do {
//        First parameter we pass here shoould conform to protocol "Decodable" so when we defined struct Model we conform it to "Decodable" protocol.
        let decodedData = try decoder.decode(Model.self, from: data)
        return decodedData
    } catch {
//        This will be executed if we somehow het error while decoding data
        print(error)
        return nil
    }
}

This is how we parse data from API/ REST API/ Web Service.

Extensions in Swift

Neeraj Gupta — Wed, 16 Dec 2020 13:56:05 +0000

Brief Introduction About Swift

Extensions in Swift

Extensions add new functionality to an existing class, structure, enumeration, or protocol type. This includes the ability to extend types for which you do not have access to the original source code (known as retroactive modeling)”

Extensions in Swift can:

Add computed instance properties and computed type properties
Define instance methods and type methods
Provide new initializers
Define subscripts
Define and use new nested types
Make an existing type conform to a protocol

Syntax for Extension


extension someType {
// functionality to add goes here
}

Coding Example on Extensions

Let's say i want some inbuilt function for integers to increment and decrement by one. Let's make one


extension Int {
    func incrementByOne() -> Int  {
        return (self + 1)
    }
    func decrementByOne() -> Int {
        return (self - 1)
    }
}

let number : Int = 2
print(number.incrementByOne()) //3
print(number.decrementByOne()) //1

Here self refers to the value on which operation is done.

One more example to show you how you can use extensions in protocols

protocol Human {
    func walking()
    func sleeping()
}

class Men : Human {
    func walking() {
        print("Men is walking")
    }

    func sleeping() {
        print("Men is sleeping")
    }

}

extension Human {
    func eating(person : String) -> String {
        return ("\(person) is eating")
    }
}

let objMen = Men()
print(objMen.eating(person : "Men")) //Men is eating

Here as we can see that we didn't provide eating method in protocol but is still available for class conforming to that protocol.

Hope, it helps and if you would like to add to it. Comment Below.

Guard Statements in Swift

Neeraj Gupta — Fri, 11 Dec 2020 15:30:59 +0000

Brief Introduction About Swift

Guard Statements in Swift

A guard statement is used to transfer program control out of a scope if one or more conditions aren’t met. The value of any condition in a guard statement must be of type Bool or a type bridged to Bool. They are generally used when we want to escape out of code if statement didn't match the condition and do not go further.

Syntax For Guard Statements

guard <#condition#> else {
    <#statements#>
}

How to Use Guard and Their Control Flow in Code

//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
    guard isValidPassword(password: passwordToBeChecked) else {
        print("Password is smaller than 6 characters") //This will execute
        return
    }
    print("Password is Valid")
}

passwordTester(passwordToBeChecked: "Xcode")

Now, let's pass password greater than 6 characters

//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
    guard isValidPassword(password: passwordToBeChecked) else {
        print("Password is smaller than 6 characters")
        return
    }
    print("Password is Valid") // This will be executed
}

passwordTester(passwordToBeChecked: "Xcode12")

Why To Use Guards

I know that we can use if-else statements to carry out this task but let's first see some code then we will judge both approaches

//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
    guard isValidPassword(password: passwordToBeChecked) else {
        print("Password is smaller than 6 characters")
        return
    }
    print("Password is Valid")

//    if isValidPassword(password: passwordToBeChecked) {
//        print("Is Vaid")
//    }else {
//        print("is not valid")
//    }

    print("This statement is executed")
}

passwordTester(passwordToBeChecked: "Xcode")

//Output : Password is smaller than 6 characters

Here in above example as password is less than 6 characters so it will exit beforehand without executing any other statement but password have been greater than 6 characters then

//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
    guard isValidPassword(password: passwordToBeChecked) else {
        print("Password is smaller than 6 characters")
        return
    }
    print("Password is Valid")

//    if isValidPassword(password: passwordToBeChecked) {
//        print("Is Vaid")
//    }else {
//        print("is not valid")
//    }

    print("This statement is executed")
}

passwordTester(passwordToBeChecked: "Xcode12")

//Output: Password is Valid
//This statement is executed

Only when guard got true it executed below statements. Now let's see in case of if-else


//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
//    guard isValidPassword(password: passwordToBeChecked) else {
//        print("Password is smaller than 6 characters")
//        return
//    }
//    print("Password is Valid")

    if isValidPassword(password: passwordToBeChecked) {
        print("Password Is Valid")
    }else {
        print("Password is less than 6 characters")
    }

    print("This statement is executed")
}

passwordTester(passwordToBeChecked: "Xcode12")

//Output: Password Is Valid
//This statement is executed

In above case if executed and now let's see for else


//Guards in Swift
func isValidPassword(password : String) -> Bool {
    if password.count > 6 {
        return true
    }
    else {
        return false
    }
}

func passwordTester(passwordToBeChecked : String) {
//    guard isValidPassword(password: passwordToBeChecked) else {
//        print("Password is smaller than 6 characters")
//        return
//    }
//    print("Password is Valid")

    if isValidPassword(password: passwordToBeChecked) {
        print("Password Is Valid")
    }else {
        print("Password is less than 6 characters")
    }

    print("This statement is executed")
}

passwordTester(passwordToBeChecked: "Xcode")

//Output:Password is less than 6 characters
//This statement is executed

Here in this case the below statement print("This statement is executed") is always executing so here we can see that guard is first checking the condition and exiting us out of function without proceeding any further but in if else we are executing all statements.

We can use any approach it is something recommended by Apple to use in case you want early exit from function.

So, this is it from my side on guards. If you guys have any suggestions please comment below.

Dictionaries in Swift

Neeraj Gupta — Sun, 06 Dec 2020 15:42:19 +0000

Brief Introduction About Swift

Dictionaries

What are Dictionaries

Doctionaries are the ones which have key value pair that is every value is mapped to it's corresponding key and they are very fast to acess so they are used in API's as API's generally is a time consuming process but when we get data from database then we can acess that data very fast as they are stored in key value pairs.

How to define Dictionary

var <dictionary_name> : [< data type of key> : < data type of value> ]

We can also store array in values

var <dictionary_name> : [< data type of key> : [ < data type of value> ] ]

Few Examples on How to define dictionaries

Dictionaries without array of data types

var FinalExamScore : [String : Int] = ["Mathematics" : 80, "English" : 90, "Physics" : 70, "Chemistry" : 65]

Now, we defined a dictionary but now we want to get value from it. We can do that by subscripting that is passing key in square brackets ( [ ] ).

var FinalExamScore : [String : Int] = ["Mathematics" : 80, "English" : 90, "Physics" : 70, "Chemistry" : 65]

FinalExamScore["Mathematics"] //80

Dictionaries with array of data types

Now, we saw how we can define dictionaries with data types only. Now, what if we want to define array of data types

var SessionalScore : [String : [Int]] = ["Mathematics" : [50,80], "English" : [90,70]]

This is how we define array of data type in value

Now, how we can acess these?

var SessionalScore : [String : [Int]] = ["Mathematics" : [50,80], "English" : [90,70]]
SessionalScore["Mathematics"] //[50,80]
SessionalScore["Mathematics"]![0] //50

So, this is how we acess these values. Now always take care while force unwrapping as it can crash your app like in below example

var FinalExamScore : [String : Int] = ["Mathematics" : 80, "English" : 90, "Physics" : 70, "Chemistry" : 65]

FinalExamScore["Social Science"]! //crash

Now here we were saying that get key Social Science and we are force unwrapping and saying swift that i guarantee that there is a key with this name. But as it was not there so app crashed

We can overcome this by putting a check here and also this is a good practice

var FinalExamScore : [String : Int] = ["Mathematics" : 80, "English" : 90, "Physics" : 70, "Chemistry" : 65]

if FinalExamScore["Social Science"] != nil{
    FinalExamScore["Social Science"]
} else {
    print("No such key exist") // This statement will run
}

Are Dictionaries Reference Type or Value Type

Dictionaries are value type means they always create seperate copies rather than referencing to other dictionaries in case of copying one dictionary to other and let's confirm that in code.

var FinalExamScore : [String : Int] = ["Mathematics" : 80, "English" : 90, "Physics" : 70, "Chemistry" : 65]

var ExamScore = FinalExamScore

ExamScore["Mathematics"] // 80
FinalExamScore["Mathematics"] //80

ExamScore["Mathematics"] = 90

ExamScore["Mathematics"] //90
FinalExamScore["Mathematics"] //80

So, we confirmed that dictionaries are value types.

Hope, it help you understand dictionaries in Swift.

Protocol Oriented Programming in Swift

Neeraj Gupta — Fri, 04 Dec 2020 10:58:08 +0000

Brief Introduction About Swift

Protocols Oriented Programming in Swift

Defination

Protocol as the name suggests is a system of rules that must be implemented.

Why to use protocols

Let's say we want some common functionality that must be implemented to every class that conforms ( comply with rules ) to it. Let's say we have men and women, their body structure is different but they all have common functionality like eating, sleeping and walking,etc.

So, how can i tell swift that although they have diffferent structure but they are humans and have same functionality. Let's see that in code.

General Syntax

protocol name {
    statements
}

We use keyword protocol to tell swift that we are defining protocol

Coding Example

protocol Human {
    func eating()
    func walking()
    func sleeping()
}

class Women : Human { // Here Swift will say "Type 'Women' does not conform to protocol 'Human' and fix will be to add protcol stubs(functions)"

}

class Men : Human { // Here Swift will say "Type 'Men' does not conform to protocol 'Human' and fix will be to add protcol stubs(functions)"

}

When we will click on fix we will see something like this

protocol Human {
    func eating()
    func walking()
    func sleeping()
}

class Women : Human {
    func eating() {
        <#code#>
    }

    func walking() {
        <#code#>
    }

    func sleeping() {
        <#code#>
    }
}

class Men : Human {
    func eating() {
        <#code#>
    }

    func walking() {
        <#code#>
    }

    func sleeping() {
        <#code#>
    }
}

Now warning will go away as we have implemented all the protocol stubs. Let's add some functionality

protocol Human {
    func eating()
    func walking()
    func sleeping()
}

class Women : Human {
    func eating() {
        print("Women is eating")
    }

    func walking() {
        print("Women is walking")
    }

    func sleeping() {
        print("Women is sleeping")
    }
}

class Men : Human {
    func eating() {
        print("Men is eating")
    }

    func walking() {
        print("Men is walking")
    }

    func sleeping() {
        print("Men is sleeping")
    }

}

// Let's make instance of both classes
let objMen = Men()
let objWomen = Women()

//Let's check if all functionalities are working
objMan.walking() //Man is walking
objMan.eating() //Man is eating
objMan.sleeping() //Man is sleeping
objWomen.eating() // Women is eating
objWomen.sleeping() //Women is sleeping
objWomen.walking() //Women is walking

So, now let's make a general Person class which will tell some common fact about walking

protocol Human {
    func eating()
    func walking()
    func sleeping()
}

class Women : Human {
    func eating() {
        print("Women is eating")
    }

    func walking() {
        print("Women is walking")
    }

    func sleeping() {
        print("Women is sleeping")
    }
}

class Man : Human {
    func eating() {
        print("Man is eating")
    }

    func walking() {
        print("Man is walking")
    }

    func sleeping() {
        print("Man is sleeping")
    }
}

class Person {
    func burnCalories(gender: Human) {
        gender.walking() //Man is walking
        print("This person burned calories by walking") //This person burned calories by walking
    }
}

// Let's make instance of both classes
let objMan = Man()
let objWomen = Women()
let objPerson = Person()

objPerson.burnCalories(gender: objMan)

Here in burnCalories method we said that it's parameter gender should conform to Human protocol and when we passed objMan, we know that it conforms to Human protocol. If we had passed the class that didn't conform to Human protocol then there would had been error that the passed parameter does not conform to protocol. This way we created a general method and we can pass any class or struct that conform to this protocol. if we would have defined function like below.

class Person {
    func burnCalories(gender: Man) {
        gender.walking() //Man is walking
        print("This person burned calories by walking") //This person burned calories by walking
    }
}

In this case we are bound to pass the instance of Man class or struct. So, if we see this is not a general code and this will increase our work and will not be resusable for future or for other classes or structs and will increase our work as we won't be creating this method for every single class/struct.

I hope this gave an brief intro about protocol oriented programming. If you want to add something feel free to comment as i am myself a learner and sharing the knowledge i have with you all.

Closures in Swift ( Intro)

Neeraj Gupta — Mon, 30 Nov 2020 16:52:17 +0000

Brief Introduction About Swift

Closures in Swift

Closures are self-contained blocks of functionality that can be passed around and used in your code. Closures are similar to block in C ( Block Statements are the one in which multiple statements of code are defined inside Curly Braces ( { } ) and are treated as single statement ). We can also say that closures are similar to functions.

General Syntax

{ (<#parameters#>) -> <#return type#> in
    <#statements#>
}

Syntax Difference between Closure and Functions

Functions

Let's say we want to add two numbers then we will define a functions as:

func addTwoNumbers(numberOne: Int, numberTwo: Int) -> Int {
    return (numberOne + numberTwo)
}

addTwoNumbers(numberOne: 2, numberTwo: 3)
//Output : 5

Closures

Now let's see how closure with same functionality can be defined:

let additionOfTwoNumbers: (Int, Int) -> Int = { (numberOne, numberTwo) in
    return (numberOne + numberTwo)
}

additionOfTwoNumbers(2,3)
//Output : 5

When To Use Closures

Closures are although similar to functions but we generally use them when we want to carry out heavy and time consuming tasks like API Parsing as Closures carry out the process simantaneously alongside other code and returns data when completed.

That's it for this post see you all next time.

Octahacks 3.0

Bhavesh Goyal — Tue, 17 Nov 2020 17:48:37 +0000

OctaHacks is the annual flagship event of DSC, Chitkara University, where innovators get an opportunity to merge their creative ideas with their technical skills to build something exemplary. It's a place where your ideas will get acknowledged.
This November, OctaHacks is back with it's third edition, OctaHacks 3.0. Expect more than 36 hours of inspiring panel discussions, working and collaborating on futuristic and empowering tech products, networking opportunities with budding developers and lots of fun!

History

Octahacks was started in 2018 with having a vision of encouraging the young innovators at the National level to build something exemplary. Something that will make the life of the community easy to live in.

Octahacks = Octa + Hacks

The title of this Hackathon itself implies about the Eight different tracks that are available in which you can brainstorm and think-design-build something innovative.
The list of tracks available is:-
1.Smart-City
2.Security
3.Fintech
4.Health
5.Environment
6.Education
7.Business
8.Women Security

How to Register?

To Register for Octahacks 3.0 you can visit www.octahacks.tech from where you will be redirected to DevFolio .Firstly, you will have to create an account, then setting up your profile and then registering for this Hackathon.
You can participate in a Team (max 4 members) or participate as an individual.
If you are stuck anywhere you can refer

Judges

To Judge the innovative projects out.
1.Kamal Vaid
Google Certified Android Developer | Technology Lead
at Infosys | GDE For Google Assistant
2.Vrijraj Singh
Organizer, GDG Jalandhar | Google Developers Expert
for Firebase & Web Technologies
3.Tushar Srivastava
Technical Project Lead at Huawei Technologies India
4.Niharika Arora
GDE for Android | Contributor @ Aarogya Setu | Active Community
Contributor | Gold Medalist
5.Mohit Uniyal
Instructor and Product Engineer at Coding Blocks | Mentor
@TensorFlow at Google Code-in.
6.Suraj Kumar
SDE-2 @V-Comply

Mentors

To guide you throughout your journey.
1.Sai Siddartha Maram
SDE Intern @Invento Robotics
2.Saurabh Thakur
SDE @smallcase, GSoC 19 @AOSSIE
3.Chetan Kaushik
Product Engineer at GOJEK | Founder at TheAlgorithms | GSOC'17 @FOSSASIA
4.Harsha Vardhan
Software Engineer at Microsoft IDC | Student Researcher
5.Vedant B.
Research Intern @UPenn | Chair IEEE CIS | Microsoft Learn Student Ambassador | Data Scientist
6.Abhay Sharma
Frontend Engineer @Smallcase
7.Madhur Gupta
Android @bim | GSoC'20 @Wikimedia
8.Jai Kathuria
Developer • Learner • Designer
9.Nikhil Bansal
Android Engineer @Mutual Mobile | Open Source Contributor | Tech Speaker | Mentor and Reviewer
10.Sagar Choudhary
SDE-II @Airmeet | Mentor and Project Reviewer
11.Ayon Roy
Speaker | Doing ML Deep Learning AI Data Science Python @ FinTech | Hackathons | Internships | Community @ Kaggle Days

Student Mentors

Fun-Time

To give this virtual hackathon a real feel of offline one we will be having game nights.
To relieve out the stress our Team will be hosting some quizzes & games with live streaming on YouTube.

Prizes

Making this Version 3.0 bigger than previous versions,Prizes worth 4 Lacs will be distributed. The goodies and the swags will be directly shipped to your given shipment details.

For more Details you can visit us at www.octahacks.tech.
You can mail your queries at help@octahacks.tech
Till then stay tuned @dsc_ciet.

Convenience Initializers and Failable Initializers in Swift

Neeraj Gupta — Sun, 15 Nov 2020 18:43:46 +0000

Brief Introduction About Swift

Convenience Initializers

Designated initializers for classes are written in the same way as simple initializers for value types:

init(parameters) {
    statements
}

Convenience initializers are written in the same style, but with the convenience modifier placed before the init keyword, separated by a space:

convenience init(parameters) {
    statements
}

Swift applies the following three rules for Initializers:

A designated initializer must call a designated initializer from its immediate superclass.
A convenience initializer must call another initializer from the same class.
A convenience initializer must ultimately call a designated initializer.

This flow chart from swift documentation explains very well the above mentioned rules. Here, the initializers of subclasses are calling initializer of superclass and convenience initializer of respective classes are calling their designated initializers.

Here is a more complex example

Here also the designated initializers of subclasses are calling the initializer of their superclasses and the convenience intializers.

We won't be going in much details but this is a basic idea of convenience init.

Failable Initializer

Let's understand using example

struct Person {
    var uniqueID: String
    init(personUniqueID: String) {
        self.uniqueID = personUniqueID
    }

}
let objectPerson = Person(uniqueID: "123456789012")
print(objectPerson.uniqueID) //123456789012

So, above we created a structure which takes a unique ID for a person. Now, here we are considering that the unique ID is always of 12 digits. Now, what if a person passed some other String like "12345" then it would had printed 12345 as result. In, this case we need to apply some sort of validation. Let's see how

struct Person {
    var uniqueID: String
    init?(personUniqueID: String) {
        if personUniqueID.count < 12 {
            return nil //here this condition will run and return nil that means struct won't be created it will just get nil so here case of failable init comes in Xcode will provide us warning that "Only a failable initializer can return nil" so we will have to tell swift that this initializer is failable and we do that by adding "?" after init
        }
        self.uniqueID = personUniqueID
    }

}
let objectPerson = Person(uniqueID: "12345")
print(objectPerson.uniqueID)

The line where we returned nil, here this condition will run and return nil that means struct won't be created it will just get nil so here case of failable init comes in and Xcode will provide us warning that "Only a failable initializer can return nil" so we will have to tell swift that this initializer is failable and we do that by adding ? after init.

Hope, you got the basic idea of convenience init and failable init. Thank you in case anyone want to add more to this post comment below.

Structs and Classes in Swift

Neeraj Gupta — Mon, 09 Nov 2020 15:35:55 +0000

Brief Introduction About Swift

What are Structures and Classes

Structures and classes are general-purpose, flexible constructs that become the building blocks of your program’s code. You define properties and methods to add functionality to your structures and classes using the same syntax you use to define constants, variables, and functions.

Unlike other programming languages, Swift doesn’t require you to create separate interface and implementation files for custom structures and classes. In Swift, you define a structure or class in a single file, and the external interface to that class or structure is automatically made available for other code to use.

What we can do in Structures

So, we can define :

Variables
Methods
Subscripts are shortcuts for accessing the member elements of a collection, list, or sequence. Like we say there is array and as array is a collection of similar types ["Neeraj", "Gupta", "programmer"], so we can access it using name_of_array[index_number]. Accessing like this is called subscripting.
Initializers or what we call constructors in other languages using init(){} here we can define some values which we always need to be intialized itself when making an instance of structure or class.
Conform to protocols to provide standard functionality of a certain kind. At time protocols in out of scope of this post and we will discussing it later but for now consider it as a certain set of rules that the adopting struct or class has to follow.

Additional features we get in classes over structures

Inheritance enables one class to inherit the characteristics of another.
Type casting enables you to check and interpret the type of a class instance at runtime.
Deinitializers enable an instance of a class to free up any resources it has assigned.
Reference counting allows more than one reference to a class instance.

Examples

Structures

We define structures using struct keyword.

//General Syntax
struct structure_name {
 body
}

struct Person {
// we have to either initialize values of variables defined in structure or class or make it optional
    var firstName : String = "Neeraj"
    var lastName : String = "Gupta"

    func move(_ name : String) -> String {
        return "Person is now moving"
    }
//Above we defined a method with in/out parameter and return type string

}

let personOne = Person() // we made an instance of Person Structure
print(personOne.firstName) // we can access the variables or methods or any collection in structure or class using period/dot(.)
print(personOne.lastName) //Gupta
print(personOne.move(personOne.firstName)) // Person is now moving

var personTwo = personOne // here we made a copy of first instance and in structures copy made is not a reference to the structure from which it is copied means they will not point to same memory block in memory which you will understand soon

print(personTwo.firstName) //Neeraj
print(personTwo.lastName) // Gupta
print(personTwo.move(personTwo.firstName)) // Person is now moving

personTwo.firstName = "Deepak" // as firstName is a variable so we can change it's value. If it had been constant we wouldn't had been able to change it's value and xcode would had thrown error saying "Cannot assign property value as firstName is let constant"

print("First Name of Person One is \(personOne.firstName)") // First Name of Person One is Neeraj
print("First Name of Person Two is \(personTwo.firstName)") //First Name of Person One is Deepak

Here is a clean code snippet for you to try and tinker

struct Person {
    var firstName : String = "Neeraj"
    var middleName : String?
    var lastName : String = "Gupta"

    func move(_ name : String) -> String {
        return "Person is now moving"
    }

}

let personOne = Person()
print(personOne.firstName)
print(personOne.lastName)
print(personOne.move(personOne.firstName))

var personTwo = personOne

print(personTwo.firstName)
print(personTwo.lastName)
print(personTwo.move(personTwo.firstName))

personTwo.firstName = "Deepak"

print("First Name of Person One is \(personOne.firstName)")
print("First Name of Person Two is \(personTwo.firstName)")

Main point to note here was that in structures we make a seperate copy and they occupy seperate memory block in memory and Apple recommends to use structures and use classes where they are actually needed.

Also, we have one more important point to cover in strucutres and we will see it with another code snippet

Strcutres are immutable by default so we cannot change value inside struct normally.

struct Person2 {
    var firstName : String = "Neeraj"
    var middleName : String?
    var lastName : String = "Gupta"

    //first we have to use `mutating` keyword to tell swift that we want to destroy this copy of structure and make a new copy with particular value. So in structures when changing a value swift will destroy old copy and make a new one
    mutating func move(_ name : String) -> String {
        self.firstName = name // inside functions or closures we have to provide self keyword to tell swift that this variable belongs to parent of this method
        return "Person is now moving"
    }

}
var personThree = Person2();
print(personThree.firstName) // Neeraj
personThree.move("Deepak"); // Here in this method value of firstName will change
print(personThree.firstName) // Deepak

Clean Code Snippet ( Try tinkering with it)

struct Person2 {
    var firstName : String = "Neeraj"
    var middleName : String?
    var lastName : String = "Gupta"

    mutating func move(_ name : String) -> String {
        self.firstName = name
        return "Person is now moving"
    }

}


var personThree = Person2();
print(personThree.firstName)
personThree.move("Deepak");
print(personThree.firstName)

Classes

Classes are almost similar but with some additional powers and also as we saw structures make a seperate copy but in classes copy made is reference type which means copy made will point to same memory block. This idea is derived from C langauge family. If you are familiar with C you may have seen yourself using pointers there the one which we used to define with * to tell that this is pointer and it will point to same memory location.

This is how we define a class using class keyword. Everything is same as structure we just have to replace struct with class keyword.

class Person {
    var firstName : String = String()
    var lastName : String = String()
}

let candidate = Person()
candidate.firstName = "Neeraj"
candidate.lastName = "Gupta"
print("Candidate's First Name \(candidate.firstName)")
print("Candidate's Last Name \(candidate.lastName)")

Let's see how classes are different from strcutres

class Person {
    var firstName : String = "Neeraj"
    var lastName : String = "Gupta"

    func move() -> String {
        return "Person is now moving"
    }
}
// hope you now understand the above code snippet as it is same as structure but the only difference is of class keyword

//Let's focus on how they are seperate from structure

let personOne = Person() // we made an instance of class
print(personOne.firstName) // Neeraj
print(personOne.lastName) // Gupta
print(personOne.move()) // Person is now moving

var personTwo = personOne // Here we made a copy of class which are pointing to same memory means change in one instance is gonna effect other instance

print(personTwo.firstName) // Neeraj
print(personTwo.lastName) // Gupta
print(personTwo.move()) // Person is now moving

personTwo.firstName = "Deepak" // Changed value of firstName

print("First Name of Person One is \(personOne.firstName)") // First Name of Person One is Deepak
print("First Name of Person Two is \(personTwo.firstName)") // First Name of Person One is Deepak

Clean Code Snippet for you to try

class Person {
    var firstName : String = "Neeraj"
    var middleName : String?
    var lastName : String = "Gupta"

    func move() -> String {
        return "Person is now moving"
    }
}

let personOne = Person()
print(personOne.firstName)
print(personOne.lastName)
print(personOne.move())

var personTwo = personOne

print(personTwo.firstName)
print(personTwo.lastName)
print(personTwo.move())

personTwo.firstName = "Deepak"


print("First Name of Person One is \(personOne.firstName)")
print("First Name of Person Two is \(personTwo.firstName)")

**Interesting point to note is Classes are mutable as they point to a memory location and not make a new copy every time so we can change value inside class

This was the main difference between structures and classes that structures are not reference types but classes are

Initializers

Initializers are used to provide some values prior to making an instance of class or structure but as we used above we can provide default values to classes or structures. We have one advantage of initializers that we can define multiple initializers and use any while making instance. Let's see in an example below

Also we saw above that swift automatically creates a initializer for structures

class Color {
    var red, blue, green: Double
    init(red: Double, blue: Double, green: Double) {
        self.red = red
        self.blue = blue
        self.green = green
    }

    init(white: Double) {
        self.red = white
        self.blue = white
        self.green = white
    }
}

let magenta = Color(red: 1.0, blue: 0.0, green: 1.0)

print(magenta.red)//1.0
print(magenta.blue) //0.0
print(magenta.green) //1.0
let white = Color(white: 0.5)

print(white.red) //0.5
print(white.blue) //0.5
print(white.green) //0.5

Above we defined multiple intializers and depending on number of parameters we pass we can access different initializers.

**A point to note here that swift do not allow reinitialization in classes and structures. Here is an example

struct Person {
    let name : String = "Neeraj"
    init() {
        name = "Deepak" // Here swift will give error that name should be initialized once. So, either intialize it once or make the property variable/mutable by replacing 'let' with 'var'
    }
}

let user = Person()
user.name

So, this was all about designated initializer. We have two more types one is convenience init and failable init which was introduced in swift 5.

Deinitializers

A deinitializer is called immediately before a class instance is deallocated. You write deinitializers with the deinit keyword, similar to how initializers are written with the init keyword. Deinitializers are only available on class types.

class Bank {
    static var coinsInBank = 10_000
    static func distribute(coins numberOfCoinsRequested: Int) -> Int {
        let numberOfCoinsToVend = min(numberOfCoinsRequested, coinsInBank)
        coinsInBank -= numberOfCoinsToVend
        return numberOfCoinsToVend
    }
    static func receive(coins: Int) {
        coinsInBank += coins
    }
}

class Player {
    var coinsInPurse: Int
    init(coins: Int) {
        coinsInPurse = Bank.distribute(coins: coins)
    }
    func win(coins: Int) {
        coinsInPurse += Bank.distribute(coins: coins)
    }
    deinit {
        Bank.receive(coins: coinsInPurse)
    }
}

var playerOne: Player? = Player(coins: 100)
print("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
// Prints "A new player has joined the game with 100 coins"
print("There are now \(Bank.coinsInBank) coins left in the bank")
// Prints "There are now 9900 coins left in the bank"

playerOne!.win(coins: 2_000)
print("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
// Prints "PlayerOne won 2000 coins & now has 2100 coins"
print("The bank now only has \(Bank.coinsInBank) coins left")
// Prints "The bank now only has 7900 coins left"

playerOne = nil
print("PlayerOne has left the game")
// Prints "PlayerOne has left the game"
print("The bank now has \(Bank.coinsInBank) coins")
// Prints "The bank now has 10000 coins"

Basic Commands of Linux.

Bhavesh Goyal — Thu, 05 Nov 2020 17:09:05 +0000

Recommended
Installed virtual box and ubuntu.||System Dual booted with Ubuntu.

Basic Terminologies to start with:

Kernel − The kernel is the heart of the operating system. It interacts with the hardware and most of the tasks like memory management, task scheduling and file management.
Shell − The shell is the utility that processes your requests. When you type in a command at your terminal, the shell interprets the command and calls the program that you want. The shell uses standard syntax for all commands. C Shell, Bourne Shell and Korn Shell are the most famous shells which are available with most of the Unix variants.
Commands and Utilities − There are various commands and utilities which you can make use of in your day to day activities. cp, mv, cat and grep, etc. are few examples of commands and utilities. There are over 250 standard commands plus numerous others provided through 3rd party software. All the commands come along with various options.
Files and Directories − All the data of Unix is organized into files. All files are then organized into directories. These directories are further organized into a tree-like structure called the filesystem.
Basically you can think of directory as a folder in your system.

Basic commands of Linux:-
1.pwd:-To check the present directory in which you are working
right now.

2.ls:-To list the files and directories stored in the current
directory/folder.
Some extensions are:-
ls -l:-To list in the some details of the files in a list format.
ls -a:-To list all the files of a directory including the hidden files.
ls -ld:-To list all the directories within a present directory.

3.cd:-To change the current directory to another.
Some useful commands of this:-
cd ..:-To move to directory that is one level up of pwd.
cd /:-This command is used to change directory to the root directory, The root directory is the first directory in your filesystem hierarchy.
cd ~:-To move back to the home directory.
cd -:-To visit last directory.
cd dir_1/dir_2/dir_3:-This command is used to move inside a directory from a directory.

4.touch:-To create blank files.

5.cat:-To create files with content and to show the content of the file.
It has two situations:-

No such file pre-exists in the directory:- It will create a file & you can enter the content.
File pre-exists with the same name in the directory:- It will display the contents of that file.

6.wc:-To get a count of the total number of lines, words, and characters contained in a file.
Syntax:-wc filename
Output:- 2 19 103 filename
This implies that it has 2 lines,19 words,103 characters and name of the file is 'filename'.

7.cp:-To make a copy of a file.
Syntax:-cp FILENAME COPIED_FILE_NAME
cp filename copyfile:-This will create the file in the same directory named copyfile which is the copy of filename.
Syntax:-cp FILENAME DESTINATION
cp filename /home/Desktop:-This will create a copy of file named filename at the mentioned location i.e Desktop.

8.mv:-To change the name of a file or a directory.
Syntax:-mv old_file new_file

9.rm:-To delete an existing file.
Syntax:-rm filename1

10.mkdir:-To make a directory.
Syntax:-mkdir dir1

11.rmdir:-To remove a directory.
Syntax:-rmdir dir1

Note − To remove a directory, make sure it is empty which means there should not be any file or sub-directory inside this directory.

12.grep:-To search something(any pattern of characters) in a file.
Synatx:-grep "Helllo" filename
This will search for "Hello" in the file named filename and will display all the lines of that file that contains "Hello" in them.

Thanks for reading.
Will be back soon with some more commands.

Forem: DSC CIET

Creating Hello World App in Flutter

Now run your app using

App will look like this

Sets in Swift

Brief Introduction About Swift

Sets in Swift

Syntax to Define Sets

Hashing

Code Example

Inbuilt Functions

Custom Sets

API Parsing Using Decodable Protocol in Swift

Brief Introduction About Swift

Steps involved in Swift API Parsing

Code Example

Extensions in Swift

Brief Introduction About Swift

Extensions in Swift

Syntax for Extension

Coding Example on Extensions

Guard Statements in Swift

Brief Introduction About Swift

Guard Statements in Swift

Syntax For Guard Statements

How to Use Guard and Their Control Flow in Code

Why To Use Guards

Dictionaries in Swift

Brief Introduction About Swift

Dictionaries

What are Dictionaries

How to define Dictionary

Few Examples on How to define dictionaries

Dictionaries without array of data types

Dictionaries with array of data types

Are Dictionaries Reference Type or Value Type

Protocol Oriented Programming in Swift

Brief Introduction About Swift

Protocols Oriented Programming in Swift

Defination

Why to use protocols

General Syntax

Coding Example

Closures in Swift ( Intro)

Brief Introduction About Swift

Closures in Swift

General Syntax

Syntax Difference between Closure and Functions

Functions

Closures

When To Use Closures

Octahacks 3.0

History

Octahacks = Octa + Hacks

Sponsors

Platform Partners

Community Partners

How to Register?

Judges

Mentors

Student Mentors

Fun-Time

Prizes

Convenience Initializers and Failable Initializers in Swift

Brief Introduction About Swift

Convenience Initializers

Failable Initializer

Structs and Classes in Swift

Brief Introduction About Swift

What are Structures and Classes

What we can do in Structures

Additional features we get in classes over structures

Examples

Structures

Classes

Initializers

Deinitializers

Basic Commands of Linux.