DEV Community: Kunal Kamble

Building Optional from scratch

Kunal Kamble — Fri, 02 May 2025 12:50:30 +0000

From this article 2 Minute Tips: The Dark Secret of Optionals I got to know that the Optionals are nothing but an Enum . I started experimenting: How can we build Optional from scratch

Enter Schrödinger's Cat or … a box

You might have heard of Schrödinger’s Cat — the thought experiment where a cat in a box is both alive and dead until you check. That's basically an Optional, right? A value that might exist... or not.

So, let's turn this idea into code:

enum 📦<Value> {
    case 😺(Value)
    case 😵

    init(_ from: Value) {
        self = .😺(from)
    }
}

Now we can do:

let x: 📦 = .😺(123)
let y: 📦 = .😵

But that's not quite as convenient as Swift's native syntax: let x: Int? = 123.

Can we make ours feel just as nice?

Literal support

Swift lets types conform to ExpressibleByNilLiteral. Let’s do that:

extension 📦: ExpressibleByNilLiteral {
    init(nilLiteral: ()) {
        self = .😵
    }
}

Now we can say:

let y = nil as 📦<Int>

Note: we still need to add as since nil as no type context.

Nice! But we can't do let x: 📦<Int> = 123 directly — Swift won't let us. As this StackOverflow post explains, that’s a compiler-level limitation.

But hey, we are creative. Let’s define a custom postfix operator to return the optional:

postfix operator ❓
postfix func ❓<T>(value: T) -> 📦<T> {
    .😺(value)
}

Now the usage becomes:

let x = 123❓   // same as .😺(123)
let y = nil as 📦<Int> // same as .😵

Lets implement force unwrapping

Again we can use a custom postfix operator for this

postfix operator ❗
postfix func ❗<T>(value: 📦<T>) -> T {
    switch value {
    case .😺(let v):
        return v
    case .😵:
        fatalError("Cat is dead Bruh!")
    }
}

Nil Coalescing

Lets add ??-like operator

infix operator ❓➡️: NilCoalescingPrecedence
func ❓➡️<T>(lhs: 📦<T>, rhs: @autoclosure () -> T) -> T {
    switch lhs {
    case .😺(let value):
        return value
    case .😵:
        return rhs()
    }
}

let value1 = x ❓➡️ 999  // 123
let value2 = y ❓➡️ 999  // 999

Optional Chaining

This was the complex part that I had to workout. For this I created a wrapper Optional type which has a @dynamicMemberLookup on it.

@dynamicMemberLookup
struct _📦<Value> {
    private let storage: 📦<Value>

    init(from: 📦<Value>) {
        storage = from
    }

    subscript<T>(dynamicMember keyPath: KeyPath<Value, 📦<T>>) -> 📦<T> {
        switch storage {
        case .😺(let v):
            return v[keyPath: keyPath]
        case .😵:
            return .😵
        }
    }
}

postfix operator ❔
postfix func ❔<T>(value: 📦<T>) -> _📦<T> {
    _📦(from: value)
}

let try it

struct TheInteger {
    let x: 📦<Int>
}

struct Service {
    let integer: 📦<TheInteger>
}

let service = Service(integer: TheInteger(x: 27❓)❓)
let s = service.integer❔.x // 😺(27)
print(s)

Conclusion

Why bother? — Because its fun and I got to play with under the hood stuff that I will probably not use in a production environment

Here is the complete code: https://gist.github.com/rational-kunal/96ddaf8f0da2cd03f4edac190f2263ce

Also here are the list of referneces:

Thank you!

Building a Snake Game (on terminal with Swift)

Kunal Kamble — Tue, 25 Mar 2025 19:27:40 +0000

Please checkout the repository at https://github.com/rational-kunal/SSSnake

Basic terminal configuration

To create a smooth terminal-based game, we need to control the terminal behavior by: 1) Hiding the cursor to prevent flickering and 2) Enabling raw mode to capture key presses without requiring the user to hit Enter.

static func hideCursor() {
    print("\u{001B}[?25l", terminator: "")
}

static func enableRawMode() {
    var raw = termios()
    tcgetattr(STDIN_FILENO, &raw)
    raw.c_lflag &= ~tcflag_t(ECHO | ICANON)  // Disable echo & line buffering
    raw.c_cc.0 = 1  // Min character read
    raw.c_cc.1 = 0  // No timeout
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw)
}

Rendering the Game

The game is displayed using a 2D character array (canvas). To render a frame, we print this array.
Also, instead of printing each frame anew (which causes flickering), we move the cursor to the top and update the existing buffer.

struct Terminal {
    private(set) var canvas: [[Character]] = TerminalHelper.makeCanvas()

    // Renders the canvas / frame on the terminal
    mutating func render() {
        TerminalHelper.moveCursor(x: 0, y: 0)
        for row in canvas {
            print(String(row))
        }
        fflush(stdout)
    }

    // Draws the symbol at the given position
    mutating func draw(x: Int, y: Int, symbol: Character) {
        canvas[y][x] = symbol
    }
}

To compute the size of the canvas, i.e. terminal size, we can use the ioctl function.

private struct TerminalHelper {
    static func windowSize() -> (width: Int, height: Int) {
        var ws = winsize()
        _ = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws)
        return (Int(ws.ws_col), Int(ws.ws_row) - 1)
    }

    // Create blank 2d buffer of blank characters
    static func makeCanvas() -> [[Character]] {
        let (width, height) = windowSize()
        return Array(repeating: Array(repeating: " ", count: width), count: height)
    }
}

So now we have a way to render frames on the terminal.

Get the user input

We need a non-blocking way to listen for user input. Running a background thread ensures that key presses are read continuously while the game logic runs separately.

DispatchQueue.global(qos: .userInteractive).async { [weak self] in
    while let self, self.isRunning, let key = Terminal.getKeyPress() {
        self.processInput(key)
    }
}

extension Terminal {
    static func getKeyPress() -> String? {
        var buffer = [UInt8](repeating: 0, count: 3)
        return read(STDIN_FILENO, &buffer, 3) == 1 ? String(UnicodeScalar(buffer[0])) : nil
    }
}

Game loop

There should be a loop where we will ask the game to update its state and then update the canvas and then render it.

class Game {
    lazy var terminal = Terminal()

    public func start() {
        // Start the game loop
        while isRunning {
            terminal.update() // Refresh canvas
            loop() // Update game state
            draw() // Draw updated elements
            terminal.render() // Render the frame
            usleep(100_000) // Control game speed (10 FPS)
        }
    }

    func processInput(_ key: String) {}
    func loop() {}
    func draw() {}
}

Cool now we have a basic skeleton to build the game

Snake game

Now, we can override the Game class to create our own Snake game.

class SnakeGame: Game {
    override func draw() {
        // Draw border, snake and its food
        // Like: terminal.at(x: 12, y: 33, symbol: "#")
    }

    override func loop() {
        // Update game state like move the snake spawn food if needed etc
    }

    override func processInput(_ key: String) {
        // Process inputs turn the direction of snke as needed
    }
}

Check out its implementation at SnakeGame.swift

Thanks for reading.

rational-kunal (Kunal Kamble) · GitHub

🍎 👨🏻‍💻. rational-kunal has 31 repositories available. Follow their code on GitHub.

github.com

ReverseEngineering[0]: UnReel your Instagram

Kunal Kamble — Tue, 30 Jul 2024 17:25:08 +0000

For a long time, I have wondered whether it's possible to externally modify the content of iOS apps.

Then I came across Bryce's video: Modding TikTok to only show Cat Videos
It was amazing to see how he altered the TikTok app to display only cat videos. This video helped me understand the process of reverse engineering an iOS app and modifying its code flow.

A New Challenge: Blocking Instagram Reels

To understand and learn reverse engineering myself, I tried hacking in a patch to disable Instagram Reels.
(A bit of context: I kept involuntarily opening Instagram and going to the reels tab in my free time. So, I wanted to modify the app to prevent this.)

Get the decrypted `ipa` file of Instagram

Like the .apk file on Android, iOS uses the .ipa file format, the "iOS package for the App Store".
Apple encrypts the .ipa file downloaded from the app store, making it impossible to directly use for reverse engineering.
According to the video, I obtained the debuggable .ipa from https://armconverter.com/decryptedappstore/us/instagram.

FLEXify the Instagram

FLEX is a tool for debugging UI, memory, network, and other issues. It is much easier than debugging via terminal, so I am integrating this first.
To do this (and to add our future script to modify content), we need to create a new framework, preferably in Objective C. We can create a Framework from Xcode > Create New Project > iOS > Framework.
We should add the code there to launch the FLEX tool after a 2-second delay.

#import <FLEX.h>

@implementation NoReels

+ (void)load {
    // After 2s launch flex tool
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [FLEXManager.sharedManager showExplorer];
    });
}

@end

Injecting the Framework

To inject this framework, use the sideloadly. It installs .ipa files on iPhones without requiring them to be jailbroken. I am still determining how this works, but you just need to add your framework. After building the framework source, you can find the framework in Product > Show Build Folder in Finder.

Unwanted crashing

After I launched the app, it crashed with the following exception

Thread 1: "*** -[NSFileManager enumeratorAtURL:includingPropertiesForKeys:options:errorHandler:]: URL is nil"

I couldn't deduce the issue without direct access to the code, but it seemed that an invalid parameter was being sent to the method above. To explore possible solutions, I swizzled the method to only call the original method when the parameters passed to it were valid.

@interface NSFileManager (Swizzling)
@end

@implementation NSFileManager (Swizzling)

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];

        SEL originalSelector = @selector(enumeratorAtURL:includingPropertiesForKeys:options:errorHandler:);
        SEL swizzledSelector = @selector(swizzled_enumeratorAtURL:includingPropertiesForKeys:options:errorHandler:);

        Method originalMethod = class_getInstanceMethod(class, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);

        method_exchangeImplementations(originalMethod, swizzledMethod);
    });
}

- (NSDirectoryEnumerator<NSURL *> *)swizzled_enumeratorAtURL:(NSURL *)url
     includingPropertiesForKeys:(NSArray<NSURLResourceKey> *)keys
                        options:(NSDirectoryEnumerationOptions)mask
                   errorHandler:(BOOL (^)(NSURL *url, NSError *error))handler {
    if (url == nil) {
        NSLog(@"[NoReels] enumeratorAtURL called with nil url");
        return nil;
    }

    return [self swizzled_enumeratorAtURL:url includingPropertiesForKeys:keys options:mask errorHandler:handler];
}

@end

This bit of code fixed the crash! So now I was able to launch instagram with the FLEX tool.

Debugging the UI

With the Flex tool, I found the reel button displayed using IGTabBarButton inside the IGTabBarController view controller. I also found a method -[IGTabBarController _discoverVideoButtonPressed] that seems to have been used to launch the reels tab.

Blocking the Reels Tab

So, to block the reels tab, we can swizzle the above method to launch a new view controller of our choosing instead of the original execution to open reels.

#import "NoReels.h"
#import <objc/runtime.h>


@implementation NoReels

+ (void)load {
    // Swizzle `-[IGTabBarController _discoverVideoButtonPressed]` to call our implementation
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class igTabBarControllerClass = NSClassFromString(@"IGTabBarController");

        SEL originalSelector = NSSelectorFromString(@"_discoverVideoButtonPressed");
        SEL swizzledSelector = @selector(swizzled_discoverVideoButtonPressed);

        Method swizzledMethod = class_getInstanceMethod(self, swizzledSelector);

        class_addMethod(igTabBarControllerClass,
                        method_getName(swizzledMethod),
                        method_getImplementation(swizzledMethod),
                        method_getTypeEncoding(swizzledMethod));

        Method originalMethod = class_getInstanceMethod(igTabBarControllerClass, originalSelector);
        Method addedMethod = class_getInstanceMethod(igTabBarControllerClass, swizzledSelector);

        method_exchangeImplementations(originalMethod, addedMethod);
    });
}

// Launch a meme view controller
- (void)swizzled_discoverVideoButtonPressed {
    UIViewController *topController = [UIApplication sharedApplication].keyWindow.rootViewController;
    while (topController.presentedViewController) {
        topController = topController.presentedViewController;
    }

    UIViewController *memeVC = [[MemeImageViewController alloc] init];
    [topController presentViewController:memeVC animated:YES completion:nil];
}

@end

With this, the user will see a meme view controller upon tapping the reel button.

Conclusion

This was a basic introduction to reverse engineering for me, demonstrating how to reverse engineer and implement patches for iOS applications. This will also help me with my Instagram addiction.

Thank you.

rational-kunal / NoReelsOnInstagram

Reverse engineering instagram app to disable reels.

rational-kunal (Kunal Kamble) · GitHub

🍎 👨🏻‍💻. rational-kunal has 25 repositories available. Follow their code on GitHub.

github.com

Let’s highlight

Kunal Kamble — Sun, 02 Jun 2024 09:08:29 +0000

Our team has been diligently adding screenshots to highlight the UI improvements made by PRs. While this approach has been beneficial in pinpointing changes, it has become a cumbersome task when multiple UI elements are updated. The need to adhere to this guideline often results in the addition of numerous screenshots, which is a time-consuming process.

That's when I had a breakthrough: What if we could draw a border directly in the app to highlight changes? This would eliminate the bottleneck of manually adding borders by quick edit.
And here we are.

The plan is to create border drawing functionality:

A simple keypress should trigger it.
It should be separate from the app, i.e., the drawing should not affect it.
We should be able to draw rectangles by just swiping.

Trigger drawing functionality by keyboard keypress

I had already seen similar functionality in the FLEX tool, so that was my starting point. Interestingly, an app on a simulator captures keyboard events with UIPhysicalKeyboardEvent and exposes _modifiedInput, _isKeyDown, etc. As these are internal classes and Swift is a type-safe language, we need to use key-value pairs to access those. To intercept all events to the application, swizzled UIApplication.sendEvent(_:).

// Hack: To look into keyboard events
extension UIEvent {
    var modifiedInput: String? { self.value(forKey: "_modifiedInput") as? String }
    var isKeyDown: Bool? { self.value(forKey: "_isKeyDown") as? Bool }
}

class ShortcutManager {
    var actionsForKeyInputs: [String: () -> Void] = [:]

    // Registers a action to be performed when "key" is presseed by user
    // Note: This will override existing action for the "key"
    func registerShortcut(withKey key: String, action: @escaping () -> Void) {
        actionsForKeyInputs[key] = action
    }

    func handleKeyboardEvent(pressedKey: String) {
        if let action = actionsForKeyInputs[pressedKey] {
            action()
        }
    }

    func interceptedSendEvent(_ event: UIEvent) {
        guard event.isKeyDown ?? false else { return }
        if let input = event.modifiedInput {
            handleKeyboardEvent(pressedKey: input)
        }
    }
}

// Handle siwizzling: Just call `performSwizzling()`
// Expect call to `ShortcutManager.interceptedSendEvent(_: UIEvent)` when any event is performed on `UIApplication`.
extension ShortcutManager {
    static func _swizzle() {
        let originalSelector = #selector(UIApplication.sendEvent(_:))
        let swizzledSelector = #selector(UIApplication.swizzled_sendEvent(_:))

        guard let originalMethod = class_getInstanceMethod(UIApplication.self, originalSelector),
              let swizzledMethod = class_getInstanceMethod(UIApplication.self, swizzledSelector) else {
            return
        }

        let didAddMethod = class_addMethod(UIApplication.self, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod))

        if didAddMethod {
            class_replaceMethod(UIApplication.self, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod))
        } else {
            method_exchangeImplementations(originalMethod, swizzledMethod)
        }
    }
}

extension UIApplication {
    @objc func swizzled_sendEvent(_ event: UIEvent) {
        ShortcutManager.sharedInstance.interceptedSendEvent(event)

        // Call original
        swizzled_sendEvent(event)
    }
}

^{Check out the complete code and a few improvements at github/rational-kunal/Picaso/ShortcutManager.swift}

Launch drawing functionality separate from the app

We can create a separate UIWindow and show it on top of the current window to keep our drawing functionality separate from the app's views.
I created a CanvasManager that will toggle our toggle functionality on the x key press.

class CanvasManager {
    var isCanvasActive: Bool { self.canvasWindow.windowScene != nil }

    /// Default initialization
    /// - Shortcut "x" to toggle canvas
    static func defaultInitialization() {
        ShortcutManager.sharedInstance.registerShortcut(withKey: "x",
                                                        action: {
            CanvasManager.sharedInstance.toggleCanvas()
        })
    }

    public func toggleCanvas() {
        isCanvasActive ? hideCanvas() : showCanvas()
    }

    public func showCanvas() {
        guard let windowScene = UIApplication.shared.activeWindowScene else { return }
        canvasWindow.rootViewController = makeRootViewController()
        canvasWindow.windowScene = windowScene
        canvasWindow.isHidden = false
    }

    public func hideCanvas() {
        canvasWindow.rootViewController = nil
        canvasWindow.windowScene = nil
        canvasWindow.isHidden = true
    }
}

^{Check out the full code at github/rational-kunal/Picaso/CanvasManager.swift}

Draw!

To draw a border, I created a subclass of UIView and maintained startPoint and endPoint. We will update those in touchesBegan() and touchesMoved(). Finally, draw the rectangle from startPoint and endPoint in draw().

class CanvasView: UIView {
    private var startPoint: CGPoint = .zero
    private var endPoint: CGPoint = .zero

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        guard let touch = touches.first else { return }
        startPoint = touch.location(in: self)
    }

    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
        guard let touch = touches.first else { return }
        endPoint = touch.location(in: self)
    }

    override func draw(_ rect: CGRect) {
        let rectangle = CGRect(x: min(startPoint.x, endPoint.x), y: min(startPoint.y, endPoint.y),
                               width: abs(startPoint.x - endPoint.x), height: abs(startPoint.y - endPoint.y))

        let roundedRectangle = UIBezierPath(roundedRect: rectangle, cornerRadius: 3.5)
        roundedRectangle.lineWidth = 2.5

        UIColor.clear.setFill()
        UIColor.red.setStroke()

        roundedRectangle.stroke()
    }
}

^{Check out the complete code for this at github/rational-kunal/Picaso/CanvasView.swift}

With this, we have the following output

Lets over-engineer

As further improvements, I implemented a way to resize the rectangle by dragging corners. To achieve this, we need to manage each corner and the selection state of the rectangle. I finally packaged this in a swift package for anyone who wants to check out the functionality with a quick setup.

Final comparison of before and after workflow of taking screenshots

Before	After

With this, 1) improved productivity by removing the need to edit screenshots and 2) Learn a few new things like UIPhysicalKeyboardEvent. Please check out the complete plugin at github/rational-kunal/Draw, and leave a star if you liked it.

Thank you for reading.

Open document in "Viewing" mode

Kunal Kamble — Sun, 26 May 2024 11:59:46 +0000

Have you ever opened a Google Doc and while looking through it unknowingly updated it? This adds to unnecessary history to the doc.
To prevent it one can just open the doc in "Viewing" mode. But there is no option to open the doc in "Viewing" mode by default.

After some reverse engineering, I discovered that the "Viewing" mode button is always present in the DOM once it gets added after the delay. This insight led me to write a script that ensures your Google Docs always open in "Viewing" mode by default.

Script to Open Google document in "Viewing" mode by default

;(async function () {
  // Some elements are not added to the DOM on initial load; one of such element is the menu containing "Viewing" mode.
  // Await till the mode switcher menu is added to the DOM.
  await new Promise(function (resolve) {
    var observer = new MutationObserver(function (mutations) {
      const targetContainerNode = document.querySelector('.docs-toolbar-mode-switcher-menu')
      if (!!targetContainerNode) {
        observer.disconnect()
        resolve()
        return
      }
    })

    // ".docs-toolbar-mode-switcher-menu" attaches on the body
    observer.observe(document.body, { childList: true })
  })

  const viewingModeButton = document.querySelector('.docs-toolbar-mode-switcher-viewing-menu-item')
  if (!viewingModeButton) {
    console.assert('[rational extension][doc mode] Unable to find mode buttons')
  }

  // Simulate click on viewing mode button
  simulateClick(viewingModeButton)
  console.count('[rational extension] Document mode be in "Viewing" mode')
})()

// For some reason the `HTMLElement.click()` method and just a `mousedown` event does not work here.
// To simulate click we need to fire `mousedown` followed by `mouseup` event
function simulateClick(onNode) {
  const createMouseEvent = (name) =>
    new MouseEvent(name, {
      view: window,
      bubbles: true,
      cancelable: true,
    })

  onNode.dispatchEvent(createMouseEvent('mousedown'))
  onNode.dispatchEvent(createMouseEvent('mouseup'))
}

Here is the output:

You can use this script with browser extensions like Tampermonkey. Personally, I'm compiling several such scripts into a custom extension for ease of use. Feel free to check out my project on GitHub: Rational Chrome Extensions.

Thank you for reading.

Is UIView (mostly) visible

Kunal Kamble — Sat, 25 May 2024 14:44:00 +0000

If you've ever needed to check whether a view is visible to the user, you might have used the isHidden property. However, this method falls short in scenarios where a view can appear hidden due to overlapping by other views. To address this, I created a simple extension to provide a more comprehensive visibility check.



extension UIView {

    /// Checkes if the view is (mostly) visible to user or not.
    /// Internaly it checks following things
    ///  - Should NOT be hidden
    ///  - Should NOT be completely transparent
    ///  - Bound should NOT be empty
    ///  - Should be in some window i.e. in view heirarchy
    ///  - Center should be directly visible to user i.e. NOT overlapped with other views
    var isMostlyVisible: Bool {
        guard !isHidden,
              alpha > 0,
              !bounds.isEmpty,
              let window,
              window.hitTest(window.convert(center, from: self.superview), with: nil) == self else {
            return false
        }

        return true
    }

}

Here is the extension in action:

Thank you for reading.

Xcode debugging cheatsheet

Kunal Kamble — Sun, 04 Feb 2024 08:32:30 +0000

This is a cheatsheet - starting point to look for things that you can do.
Avoided complex / 3rd party things as they require some additional setup that may not be allowed in certain projects.

Breakpoints

Breakpoint is user enabled point in code where the application pauses
Line and column breakpoints
- Pauses the program before the statement on line/column is executed
Conditions
- Execute walk method just for LadyBug: self.bugType == 1
Actions: Sound, Log message, Debug command
Symbolic breakpoints: Add breakpoint on a method without source file [UIImage systemImageNamed:]
- po $arg1 -> Receiver object
- po $arg2 -> po (SEL)$arg2 -> Method name
- po $arg3 -> First argument, and goes
Watch points: Pauses when the value changes

LLDB commands

help: Information about commands
v: Does not compile the expression instead it just dumps value from the stack
p: Evaluates and prints the output
po: Evaluates the print debug output
- description method
- Use [] syntax if . is failing due to typecasting
expression: Evaluates and prints, also stores the output in a variable
- Expressions in other languages: expression -l swift/objc -O -- <code>
alias: Creates a shortcut for complex commands
- command alias greet p @"Hello World"

Techniques

Inject code without building it: expression <sample fix/feature>
- expr [bugs addObjectsFromArray:[[self makeAntViews:20] mutableCopy]]
Short circuit / skip code execution:
- Move the debugger handle
- thread jump --by 1
Early return through a method: thread return <return value>
- NOTE: This does not always work and can be dangerous
Print the view hierarchy: po [self.view recursiveDescription]
Highlight a view:
- (UIColor *)[bug setBackgroundColor:UIColor]
- (void)[CATransition flush]: Refreshes UI
Add delay in code: expr [NSThread sleepForTimeInterval:2]
Auto layout debugging: po [self.view _autolayoutTrace]

References:

How to Parallax?

Kunal Kamble — Sat, 29 Apr 2023 08:49:12 +0000

Let's see how to create a parallax effect in your app.

First, let's define what parallax is. Parallax scrolling is a popular design technique used to create a scrolling effect by moving multiple layers of content at different speeds. It's an effective way to add visual interest and depth to your app or website. You can achieve a similar effect with UIScrollView. In this blog post, we'll explore how to create a parallax effect using UIScrollView.

To create a parallax effect with UIScrollView, we'll use two parallax sub-views. We will adjust their position based on the scroll position of the UIScrollView.

Step 1: Create the views

First, let's create our views programmatically and set up initial frames/constraints. We can do this in the viewDidLoad() method of our view controller.

class ViewController: UIViewController, UIScrollViewDelegate {

    let scrollView = UIScrollView()
    let contentView = UIView()
    let parallax1View = UIView()
    let parallax2View = UIView()
    let parallax3View = UIView()

    override func viewDidLoad() {
        super.viewDidLoad()

        scrollView.delegate = self
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(scrollView)

        contentView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.addSubview(contentView)

        parallax1View.frame = CGRect(x: 0, y: 0, width: 200, height: 100)
        parallax1View.backgroundColor = .red
        parallax1View.clipsToBounds = true
        parallax1View.translatesAutoresizingMaskIntoConstraints = false
        contentView.addSubview(parallax1View)

        parallax2View.frame = CGRect(x: 100, y: 0, width: 200, height: 100)
        parallax2View.backgroundColor = .yellow
        parallax2View.clipsToBounds = true
        parallax2View.translatesAutoresizingMaskIntoConstraints = false
        contentView.addSubview(parallax2View)

        self.setUpConstraints()
    }

    func setUpConstraints() {
        NSLayoutConstraint.activate([
            // Scroll view
            scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            scrollView.topAnchor.constraint(equalTo: view.topAnchor),
            scrollView.bottomAnchor.constraint(equalTo: view.bottomAnchor),

            // Content view
            contentView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor),
            contentView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
            contentView.topAnchor.constraint(equalTo: scrollView.topAnchor),
            contentView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
            contentView.widthAnchor.constraint(equalTo: scrollView.widthAnchor),
            contentView.heightAnchor.constraint(equalTo: scrollView.heightAnchor, multiplier: 2)
        ])
    }
}

In this code, we create the required views and set up constraints to position and size the views.

Step 2: Adjust parallax sub-view positions

Next, we need to adjust the position of the parallaxImageView based on the scroll position of the UIScrollView. We can do this in the scrollViewDidScroll(_:) method of the UIScrollViewDelegate protocol.

extension ViewController {
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        let yContentOffest = scrollView.contentOffset.y
        let ySlowerOffset = yContentOffest / 2
        let yFasterOffset = 2 * yContentOffest
        parallax1View.frame.origin.y = -ySlowerOffset
        parallax2View.frame.origin.y = -yFasterOffset
    }
}

In this code, we calculate the vertical offset of the UIScrollView and adjust the position of the parallax view.

Conclusion

In this blog, we learned how to create a very basic parallax effect using UIScrollView. We created two views, set up constraints, and adjusted their position based on the scroll position. Now you can use this technique to create stunning parallax effects in your own apps!

NSLog (Debugging) Cheat Sheet

Kunal Kamble — Sat, 22 Apr 2023 17:27:02 +0000

Purpose of this cheat sheet is to explore debugging tools for logging.

Frequently used format specifiers:

Type	Format specifier
Object (prints description)	`%@`
`NSInteger`	`%ld`
`NSUInteger`	`%lu`
`CGFloat`	`%f`
`pointer`	`%p`

More format specifiers are available on: String Format Specifiers ~ Apple Documentation

Helper method to translate objects/structures into `NSString`:

Function	Description
`NSStringFromClass`	Returns the name of a class as a string.
`NSStringFromCGRect`	Returns a string formatted to contain the data from a rectangle in `{{x, y}, {width, height}}` format.
`NSStringFromCGSize`	Returns a string formatted to contain the data from a size data structure in `{width, height}` format.
`NSStringFromCGPoint`	Returns a string formatted to contain the data from a point in `{x, y}` format.
`NSStringFromRange`	Returns a string representation of a range in `{location, length}` format.

More (less used) methods:

NSStringFromSelector
NSStringFromProtocol
NSStringFromCGVector
NSStringFromMapTable
NSStringFromUIOffset
NSStringFromHashTable
NSStringFromCGAffineTransform
NSStringFromDirectionalEdgeInsets

Debugging wrapper for NSLog

#define Debug(fmt, ...) NSLog((@"%s [Line %d] " fmt), __PRETTY_FUNCTION__, __LINE__, ##__VA_ARGS__)

Log a backtrace of your stack

NSLog(@"%@", [NSThread callStackSymbols]);

2023-04-22 22:37:20.001544+0530 just-objc[5829:186391] (
    0   just-objc                           0x000000010099dda8 -[ViewController viewDidLoad] + 84

<trimmed ...>

    28  UIKitCore                           0x0000000107ebeff0 -[UIApplication _run] + 868
    29  UIKitCore                           0x0000000107ec2f3c UIApplicationMain + 124
    30  just-objc                           0x000000010099e024 main + 120
    31  dyld                                0x0000000100b2d514 start_sim + 20
    32  ???                                 0x0000000100d85f28 0x0 + 4309147432
    33  ???                                 0xdf35000000000000 0x0 + 16083761644223594496
)

DEV Community: Kunal Kamble

Building Optional from scratch

Enter Schrödinger's Cat or … a box

Literal support

Lets implement force unwrapping

Nil Coalescing

Optional Chaining

Conclusion

Building a Snake Game (on terminal with Swift)

Basic terminal configuration

Rendering the Game

Get the user input

Game loop

Snake game

rational-kunal (Kunal Kamble) · GitHub

ReverseEngineering[0]: UnReel your Instagram

A New Challenge: Blocking Instagram Reels

Get the decrypted ipa file of Instagram

FLEXify the Instagram

Injecting the Framework

Unwanted crashing

Debugging the UI

Blocking the Reels Tab

Conclusion

rational-kunal / NoReelsOnInstagram

Reverse engineering instagram app to disable reels.

rational-kunal (Kunal Kamble) · GitHub

Let’s highlight

Trigger drawing functionality by keyboard keypress

Launch drawing functionality separate from the app

Draw!

Lets over-engineer

Open document in "Viewing" mode

Is UIView (mostly) visible

Xcode debugging cheatsheet

Breakpoints

LLDB commands

Techniques

How to Parallax?

Step 1: Create the views

Step 2: Adjust parallax sub-view positions

Conclusion

NSLog (Debugging) Cheat Sheet

Frequently used format specifiers:

Helper method to translate objects/structures into NSString:

Debugging wrapper for NSLog

Log a backtrace of your stack

Get the decrypted `ipa` file of Instagram

Helper method to translate objects/structures into `NSString`: