Programming on Infinite Script

Build an iOS App from Scratch with SwiftUI

Sun, 24 Jul 2022 15:22:00 +0000

Background

On Valentine’s day 2021 I put together a small static website, Infinite Love, to hold a handful of pictures. Because it is static, adding a new photo means editing the source and redeploying, not something you want to do from your phone. So I set out to wrap it in an iOS app with a proper “new post” button.

I had done plenty of web development, but this was my first time writing anything for iOS. What follows is the walkthrough I wish I’d had: taking an empty Xcode project all the way to an app running on a real iPhone.

Build PyTorch Extensions with CUDA and CFFI

Wed, 28 Mar 2018 12:30:58 +0000

Deprecated warning: PyTorch 1.0+ replaced the old TH/THC tensor backend with ATen, and the torch.utils.ffi toolchain described here was removed along the way. If you target PyTorch 1.0 or newer, write your extensions with torch.utils.cpp_extension instead, see this GitHub repository for a working example. The article below documents the older CFFI-based approach and is kept for reference.

Python is one of the most popular languages for deep learning, but as an interpreted language it is slow at tight numerical loops. Most of the time this does not matter, because the heavy lifting happens inside libraries written in C and CUDA. It starts to matter the moment you need an operation that the framework does not provide out of the box.

Lua in a Nutshell: A Quick Tutorial for Lua

Tue, 09 Jan 2018 02:10:34 +0000

I’m reading source code written with Torch these days. Torch is a well-known deep learning framework written in Lua.

So I summarize its grammar and provide a quick tutorial here.

Getting Started

Like many languages, Lua is case-sensitive.

The following code outputs “Hello World” with Lua. Note that the semicolon at the end of a line is optional, like JavaScript.

print('Hello World')

You can use the interpreter of Lua in the command line:

Introduction to Java Virtual Machine

Fri, 07 Aug 2015 07:27:00 +0000

Note: This article has been updated for Java 8 and later. The original 2015 version described the Permanent Generation (PermGen), which Java 8 removed and replaced with Metaspace (JEP 122); the garbage-collection section has also been rewritten to cover the modern HotSpot collectors (G1, ZGC, Shenandoah). The behaviors described here are those of HotSpot; other JVM implementations may differ.

What is JVM?

The Java Virtual Machine is the cornerstone of the Java platform. It is the component responsible for Java’s hardware and operating-system independence, the small size of its compiled code, and its ability to protect users from malicious programs.

Difference Between require and include in PHP

Fri, 14 Nov 2014 06:33:06 +0000

One of the most common questions I get from PHP beginners is: why are there four different ways to pull one file into another?

There is include, include_once, require, and require_once. They look almost interchangeable, but picking the wrong one can either hide a fatal bug or crash a page that should have kept running.

The four are really just combinations of two independent choices:

include vs require: what happens when the file is missing. include emits a warning and keeps going; require stops the script with a fatal error.
plain vs _once: how many times the file may be loaded. The plain form loads the file on every call; the _once form loads it at most once per request.

One note before we start: despite the parentheses you often see, include and require are language constructs, not functions. Both require 'core.php'; and require('core.php'); work, but the manual recommends the parenthesis-free form, which is what I’ll use throughout.

Java Collections Framework

Thu, 30 Oct 2014 13:40:38 +0000

Almost all collections in Java are derived from the java.util.Collection interface. Collection defines the basic parts of all collections. The interface states the add() and remove() methods for adding to and removing from a collection respectively. Also required is the toArray() method, which converts the collection into a simple array of all the elements in the collection. Finally, the contains() method checks if a specified element is in the collection. The Collection interface is a subinterface of java.lang.Iterable, so any Collection may be the target of a for-each statement. (The Iterable interface provides the iterator() method used by for-each statements.) Additionally, Collection is a generic, so any collection can be written to store any class. For example, a Collection<String> can hold strings, and the elements can be used as strings without any casting required.

The String Constant Pool

Mon, 06 Oct 2014 08:47:31 +0000

The String Constant Pool is a JVM-wide cache of string literals: when different parts of your code reference a string with the same content, they can share a single String object instead of allocating a new one each time. This is possible only because String is immutable in Java, combined with the String interning mechanism. In other words, the pool is an application of the Flyweight design pattern.

String Pool Examples

String s1 = "Hello";
String s2 = "Hello";
String s3 = "Hel" + "lo";
String s4 = "Hel" + new String("lo");
String s5 = new String("Hello");
String s6 = s5.intern();
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // true
System.out.println(s1 == s4); // false
System.out.println(s4 == s5); // false
System.out.println(s1 == s6); // true

Explanation

The references of s1, s2, s3, and s6 all point to the same pooled object, while s4 and s5 do not. Here is why:

The 23 Gang of Three Design Patterns

Sat, 04 Oct 2014 02:09:13 +0000

Design patterns represent the best practices used by experienced object-oriented software developers. Design patterns are solutions to general problems that software developers faced during software development. These solutions were obtained by trial and error by numerous software developers over quite a substantial period of time.

This tutorial will take you through step by step approach and examples using Java while learning Design Pattern concepts.

Three Types of Design Patterns

Design patterns are divided into three fundamental groups: Behavioral Patterns, Creational Patterns, and Structural Patterns.

Difference between wait() and sleep(), yield() in Java

Tue, 23 Sep 2014 14:13:41 +0000

The difference between wait() and sleep(), or between sleep() and yield(), is one of the oldest questions asked in Java interviews. All three pause the currently running thread, but they differ in who owns them, whether they release the lock, and how the thread wakes up again.

TL;DR

	`sleep()`	`yield()`	`wait()`
Defined in	`Thread`	`Thread`	`Object`
Static method?	Yes	Yes	No
Releases the lock/monitor?	No	No	Yes
Must hold the monitor (be in `synchronized`)?	No	No	Yes
Wakes up when	timeout expires or interrupted	the scheduler decides (maybe immediately)	`notify()`/`notifyAll()`, timeout, or interrupt
Typical use	pause for a fixed time	hint to give up the CPU	coordination between threads

JavaDoc Definition

Thread Class

public static void sleep(long millis[, int nanos]) throws InterruptedException

Object Initialization Order in Java

Mon, 22 Sep 2014 08:51:05 +0000

An object is a chunk of memory bundled with the code that manipulates memory. In the memory, the object maintains its state (the values of its instance variables), which can change and evolve throughout its lifetime. To get a newly-created object off to a good start, its newly-allocated memory must be initialized to a proper initial state. Here we take an in-depth look at the mechanisms Java uses to manage object initialization.

HashMap Internal Implementation Analysis in Java

Tue, 09 Sep 2014 03:38:29 +0000

HashMap is one of the most common topics in Java interviews, and “How does HashMap work?” has a deceptively simple one-line answer: “On the principle of hashing.” To say anything more, you need to know how hashing works and how HashMap applies it internally.

This post assumes you already know the basics of using a HashMap; if not, start with the official Java docs. The walkthrough below uses the pre-Java-8 source as its baseline; wherever Java 8+ changed the implementation, an inline Note flags it.

How To Convert Byte[] Array To String in Java

Sun, 03 Nov 2013 08:00:51 +0000

It is common to convert a String into a byte[] array and back again. The catch is that how you convert depends on what the bytes actually are: human-readable text in some encoding, or arbitrary binary data such as the output of a cipher. Using the wrong approach silently corrupts your data.

Note: This post has been updated to always specify a charset explicitly and to cover the binary-data case. The original advice — new String(bytes) — relies on the platform’s default charset, which makes the result differ from machine to machine, and it cannot round-trip binary data at all. Both pitfalls are addressed below.

Use SQLite in Qt

Mon, 15 Jul 2013 15:03:48 +0000

SQLite is a lightweight, file-based database that needs no separate server process, which makes it a perfect fit for desktop applications that want to store data locally. Qt ships with a built-in SQLite driver as part of its SQL module, so you can talk to a database without pulling in any third-party dependency. This post walks through the few steps required to set it up and run your first queries.

Convert Excel Date into Timestamp in PHP

Fri, 05 Apr 2013 08:05:30 +0000

Excel stores a date internally as a number of days since January 1, 1900.
For example: “June 9th, 2011 10:30 AM” would be stored as “40703.4375”.
40703 is the number of full days since 01/01/1900 and 0.4375 represents the time (10.5/24 = 0.4375).

When you process dates read from an Excel spreadsheet (e.g., using PHPExcel) you often want to convert them into a UNIX timestamp, i.e. a number of seconds elapsed since midnight of January 1, 1970 UTC.

Writing Your First Win32 Application with C++

Wed, 20 Mar 2013 12:20:09 +0000

Welcome to the first windows tutorial. In this tutorial, I’ll give you the basic information on how to code in windows and we’ll go over a few important details first.

Messages

The basic windows program has two important functions inside. The first one is the event handler(I’ll talk about this one later on) and the second one is the main function(WinMain from now on). WinMain is similar to DOS’ main function, in fact, WinMain is called from the DOS main function but in windows, we don’t have access to the DOS main; everything is covered up by windows. Windows introduces us to messages. A message could be easily described as a pile of data that gets sent to the event handler which then tells the window what to do. A message’s name is prefixed with WM(stands for Windows Message as you might have guessed?). There are a whole lot of messages that a window can handle, however, we’ll only need a few of them. You can use these messages in many ways. For example, the message WM_CREATE, can be used for initialization purposes, it gets sent to the window when it’s created, and WM_PAINT is used when you want to draw something on the screen, and so on, you get the image. Most of the messages get sent to the window automatically; for example, when you move your mouse around you send a message to windows, and any other actions like that send messages to windows. You can also send a message to your window yourself, but you’ll probably never need to.

C# - Run Application as Administrator Automatically

Tue, 21 Aug 2012 14:46:13 +0000

In this tutorial, you will learn how you can run your application as an administrator automatically using Visual C#2012.

Adding an Application Manifest

Start by opening your C# Windows forms application.

Right click on your project name in the solution explorer and add a new item…

Select an application manifest file:

Click add.

Requiring Administrator Privileges

A new tab should open up, most of the codes in it are not important to us.
There is one line however that we need to change:

Regular Expression

Fri, 03 Aug 2012 05:32:29 +0000

In computing, a regular expression is a specific pattern that provides concise and flexible means to “match” (specify and recognize) strings of text, such as particular characters, words, or patterns of characters. Common abbreviations for “regular expression” include regex and regexp.

Basic Concepts

A regular expression, often called a pattern, is an expression that specifies a set of strings. To specify such sets of strings, rules are often more concise than lists of a set’s members. For example, the set containing the three strings “Handel”, “Händel”, and “Haendel” can be specified by the pattern H(ä|ae?)ndel (or alternatively, it is said that the pattern matches each of the three strings). In most formalisms, if there exists at least one regex that matches a particular set then there exist an infinite number of such expressions. Most formalisms provide the following operations to construct regular expressions.