The XmlExtractor is a class that will parse XML very efficiently with the XMLReader object and produce an object (or array) for every item desired. This class can be used to read very large (read GB) XML files

Given the XML file below:

<root>
	<item>
		<tag1>Value 1</tag1>
		<tag2>
			<subtag1>Sub Value 2</subtag1>
		</tag2>
	</item>
</root>

this is the pattern you would use to parse XML with XmlExtractor:

$source = new XmlExtractor("root/item", "/path/to/file.xml");
foreach ($source as $item) {
  echo $item->tag1;
  echo $item->tag2->subtag1;
}

There are four parameters you can pass the constructor

XmlExtractor($rootTags, $filename, $returnArray, $mergeAttributes)

• $rootTags Specify how deep to go into the structure before extracting objects. Examples are below
• $filename Path to the XML file you want to parse. This is optional as you can pass an XML string with loadXml() method
• $returnArray If true, every iteration will return items as an associative array. Default is false
• $mergeAttributes If true, any attributes on extracted tags will be included in the returned record as additional tags. Examples below

XmlExtractor.loadXml($xml)

Loads XML structure from a php string

XmlExtractor.getRootTags()

This will return the skipped root tags as objects as soon as they are available

XmlItem.export($mergeAttributes = false)

Convert this XML record into an array. If $mergeAttributes is true, any attributes are merged into the array returned

XmlItem.getAttribute($name)

Returns the record’s named attribute

XmlItem.getAttributes()

Returns this record’s attributes if any

XmlItem.mergeAttributes($unsetAttributes = false)

Merges the record’s attributes with the rest of the tags so they are accessible as regular tags. If unsetAttributes is true, the internal attribute object will be removed

Simple XML structure and straight forward php.

<earth>
	<people>
		<person>
			<name>
				<first>Paul</first>
				<last>Warelis</last>
			</name>
			<gender>Male</gender>
			<skill>Javascript</skill>
			<skill>PHP</skill>
			<skill>Beer</skill>
		</person>
	</people>
</earth>

$source = new XmlExtractor("earth/people/person", "/path/to/above.xml");
foreach ($source as $person) {
  echo $person->name->first; // Paul
  echo $person->gender; // Male
  foreach ($person->skill as $skill) {
    echo $skill;
  }
  $record = $person->export();
}

The first constructor argument is a slash separated tag list that communicates to XmlExtractor that you want to extract “person” records (last tag entry) from earth -> people structure.
The export method on the $person object returns it in array form, which will look like this:

array(
  'name' => array(
    'first' => 'Paul',
    'last' => 'Warelis'
  ),
  'gender' => 'Male'
  'skill' => array(
    '0' => 'Javascript',
    '1' => 'PHP',
    '2' => 'Beer'
  )
)

It’s important to note that the repeating tag “skill” turned into an array.

First create the extractor and then use loadXml() method to get the data in.

$xml = <<<XML
<house>
	<room>
		<corner location="NW"/>
		<corner location="SW"/>
		<corner location="SE"/>
		<corner location="NE"/>
	</room>
</house>
XML;

$source = new XmlExtractor("house/room");
$source->loadXml($xml);
foreach ($source as $room) {
	var_dump($room->export());
	var_dump($room->export(true));
}

The first dump will show the “corner” field that contains four empty values:

array(
  'corner' => array(
    '0' => '',
    '1' => '',
    '2' => '',
    '3' => ''
  )
)

But when you merge the attributes with the tag data, the array changes to:

array(
  'corner' => array(
    '0' => array( "location" => "NW"),
    '1' => array( "location" => "SW"),
    '2' => array( "location" => "SE"),
    '3' => array( "location" => "NE")
  )
)

This example demonstrates how to deal with attributes.

<office address="123 Main Street">
	<items total="2">
		<item name="desk">
			<size width="120" height="33" length="70">large</size>
			<image>desk.png</image>
		</item>
		<item image="cubicle.jpg">
			<name>cubicle</name>
			<size>
				<width>120</width>
				<height>33</height>
				<length>60</length>
				<size>large</size>
			</size>
		</item>
	</items>
</office>

There are a number of things going on with the above XML.
The two root tags that we have to skip to get to our items have information attached.
We can get at these with the getRootTags() method. The next issue is that both items are using attributes to define their data.
This example is a bit contrived, but it will show the functionality behind the mergeAttributes feature.
By the end of this example, we will have two items with identical structure.

$office = new XmlExtractor("office/items/item", "/path/to/above.xml");
foreach ($office as $item) {
  $compressed = $item->export(true); // true = merge attributes into the item
  var_dump($compressed);
}
foreach ($office->getRootTags() as $name => $tag) {
  echo "Tag name: {$name}";
  var_dump($tag->getAttributes());
}

Once “compressed” (exported with merged attributes) the structure of both items is the same.
In the event of an attribute having the same name as the tag, the tag takes precedence and is never overwritten.
The two items will end up looking like this:

array(
  'name' => 'desk',
  'size' => array(
    'width' => '120',
    'height' => '33',
    'length' => '70',
    'size' => 'large'
  ),
  'image' => 'desk.png'
)
array(
  'image' => 'cubicle.jpg'
  'name' => 'cubicle',
  'size' => array(
    'width' => '120',
    'height' => '33',
    'length' => '70',
    'size' => 'large'
  )
)

The root tags bit will come up with this:

Tag name: office
array(
  'address' => '123 Main Street'
)
Tag name: items
array(
  'total' => '2'
)

If your XML file has markup like this:

<art>
	<painting>
		<name>Mona Lisa</name>
	</painting>
	<sculpture>
		<name>Dying Gaul</name>
	</sculpture>
	<photo>
		<name>Afghan Girl</name>
	</photo>
</art>

The art tag contains many different items. To parse them, do this (notice the path to the tag):

$art = new XmlExtractor("art/*", "/path/to/above.xml");
foreach ($art as $name => $piece) {
  echo "Piece : " . $piece->getName();
  var_dump($piece->export());
}

The output would be something like this:

Piece : painting
array('name' => 'Mona Lisa')
Piece : sculpture
array('name' => 'Dying Gaul')
Piece : photo
array('name' => 'Afghan Girl')

If you find bugs, post an issue. I will correct or educate.

Enjoy!

pwarelis at gmail dot com

[ Description —————————]

This program automates the process of setting watchpoints to detect functions accessing a structure or block of memory.
It is capable of presenting all detected functions that write and read from a block of memory or structure.
It detects access types (ldr having a type of 32, strh having a type of 16, ldrb having a type of 8, etc)
and access offsets (str r0, [r5, 0x35] 0x35, being the offset)

Through detected access types and offsets, the program can generate a typedef structure template for the structure itself.
However, correctly estimating the size of a structure is very critical for the generation of the template.
Underestimating is OK, but overestimating is bad.

Sometimes, the game may access a memory location inconsistently. This causes problems in the generation
of a structure template, which generates false structure padding. In such a case, all relevent entries are marked as
CONFLICT in the structure template output. By fixing these conflicts manually (by choosing only one
and removing the other duplicates), the template may be input into the StructPadder module to fix the padding.

[ Protocol ——————————]

Setting up and running the MemoryAccessDetector.lua in VBA-rr and doing relevent actions to the structure in game
should generate output that looks like this:

name=s_02001B80, size=0x84
080050EC::080050F4 u8(0x00), 08035932::08035938 u8(0x06), 0809F99A::0809F9A0 u8(0x10), 
0809DEA0::0809DEC0 u8(0x04), 08034EF0::08034EFC u8(0x0E), 08034F68::08034F74 u32(0x18),

The first line contains meta information important to the MemoryAccessProtocol module.
The next lines contain a repeating pattern of entries that describe a memory access.
The format is: <function_Address>::< Memory_Access_Address> u<type_of_access>(<Offset_of_access>)
The program attempts to find the function address by searching for a push {…, lr} somewhere above.
If it detects a pop {…, pc} first, it indicates that the function address is unkown by placing a ‘?’ in its location.

[ Usage ———————————-]

1. Configure the MemoryAccessDetector.lua file by
   1a. setting the base address and the size, and name of the structure.
   1b. setting whether to scan on reads (LDRs) or writes (STRs) or both (or neither, oh well).
2. Run the script in VBA-rr while playing the relevent game you’re trying to scan.
   2a. Perform actions you think are relevent to the structure to get a better output.
   2b. (By default) Press ‘P’ after you’re done to make sure all memory access entries have been outputted.
3. Copy the output of the lua script into the file “input”.
4. Run the MemoryAccesProtocol.py module to generate a structure template in stdout.

In case the structure template containts CONFLICTS:

1. Manually go through each conflict, and remove duplicates
   (structure members of the same location yet different types).
2. (optional): Remove the tag ” CONFLICT” from the entry. so that the only comment is “// loc=0x22” for example.
3. Copy the content of the template and put it in the “input” file.
   (minus the “typdef struct{” lines and “}structName;” lines)
4. Run the StructPadder.py module to get correct padding.

[ Dependencies ——————————]

1. VBA-rr
2. Python3
3. A GBA ROM to scan

Thanks for your interest in my demonstration client of Auth0’s APIs. This is one half of a project demonstrating how one might go about implementing Auth0’s authentication API to interact with a custom backend.

This repository houses the JavaScript-based frontend server, using the Ember.js framework. The accompanying PHP-based backend server can be found here.

• An Auth0 account
• Docker
• docker-sync
• The counterpart backend server

You should begin by cloning and configuring the backend counterpart to this project first. Instructions for that can be found in it’s repository.

Next, clone this repository to your local machine:

git clone https://github.com/evansims/auth0-example-client.git

1. Sign up for an Auth0 account, if you don’t already have one, and sign in.
2. Open Auth0’s Applications dashboard and create a new Single Page Web Application.
3. In your new Application’s settings, make note of your unique Client ID and Domain. You will need these later.
4. Set the ‘Allowed Callback URLs’ endpoint to http://localhost:3000/callback.
5. Save your Application settings changes.

1. On your machine, within the cloned directory of this repository, open the config/environment.js file.
2. Find the auth0 section.
3. Set your clientId and domain to the values you made note of when you set up your Auth0 Application (above.)
4. Set your audience to match the Audience of the Auth0 API you noted while configuring the backend server.
5. Save the file.

This project assumes you have an existing Docker installation to simplify getting started. However, if you already have a working Ember CLI installation on your local machine you can build the project using the standard command line tools if you prefer.

We’ll be using docker-sync to help streamline the build process across platforms. Once you have docker-sync installed, open your shell to the cloned repository on your local machine and run:

$ docker-sync-stack start

This will begin a file sync to the Docker container and start the build process. This may take a few minutes to complete.

Once the build is done, your frontend will be accessible at http://localhost:3000 on your local machine.

To terminate the build process at any time, simply close the shell process, which on most platforms is usually accomplished by pressing CTRL+C.

Open http://localhost:3000 on your local machine to use the client.

This client demonstrates a few simple aspects:

• Authenticating users using Auth0’s SPA JS SDK with an Ember.js app
• Communicating with a custom backend server to proxy calls to Auth0’s Management API, transforming our requests and enabling the following:
  • Using Ember Data to store Auth0 user objects
  • Rendering paginated results from the Management AP, using ember-concurrency
  • Searching users with the Management API

After signing into the demonstration client with your Auth0 account, you will see a list of other users in your application.

You can paginate and view more users by selecting the ‘more users’ button at the bottom of the results.

At the top of the page you can use the search field to filter your results.

If you’re just looking for inspiration on how to do the important bits this client demonstrates, here’s where to look:

• All session handling is done in the app/services/session.js file.
  • The application route (app/routes/application.js) is the root route and always the first route called in an Ember app.
    • We use this opportunity to have Auth0’s SPA SDK check if the user has already authenticated. This automatically happens when we create the Auth0Client instance in our Session service’s getSession method.
  • We have a method for getting some basic information about the authenticated user, getUser.
  • We have a sign out method, releaseSession.
• We have an Ember Data model representing all the user objects returned by the Management API at app/models/user.js
• We use an Ember component for managing the calls to our custom backend and rendering the users at app/components/pages/accounts-list/component.js

• Documentation for Auth0’s APIs can be found here.
• Quickstarts for a variety of use cases, languages and respective frameworks can be found here.

Pull requests are welcome!

If you discover a security vulnerability within this project, please send an e-mail to Evan Sims at hello@evansims.com. All security vulnerabilities will be promptly addressed.

This demonstration project is open-sourced software licensed under the MIT license.

This Go program demonstrates the use of interface-typed objects that are declared to link some functions to their specified struct. This technique, although using the property of interface-typed objects, is not the same as demonstrated here where interface-typed arguments are passed into functions. As for the code in this repository, we can use functions as methods for the created structs since we are not passing interface-typed objects as conventional argument, but we are using them as receiver arguments instead.

Since this program is very similar to the one in the repository in this link, I’m just going to copy-paste the program manual from there as the following:

When run, the program asks the user to input the following information in the following order:

Note title
Note content
Todo
Then, the program will show messages containing the input information and, if there’s no error, will notify the user that the note and todo are successfully saved (in json file format).

There is no input validation for this program because every piece of information are in the form of free text. However, the program is designed to catch error when saving the files. The user will be notified if there’s any error while saving each file. In case of error, the program will stops after displaying the error message.

Although, the program in this project works exactly the same as the one from this link, the code structure was designed differently in order to demonstrate another way of using interface to link common methods to different struct types from different packages.

The project comprises the main.go file which contains the code of the main program, and the codes which make up the note and todo packages. The main.go file contains the code declaring interface objects that link the save and display functions in the mentioned packages to their native structs. Those functions can, in turn, be used as the structs’ methods.

Since this program works exactly as another one in a different repository as mentioned in several places above, I’m just going to copy an paste the same program flow from there as the following:

1. The user inputs the note title as a string
2. The user inputs the note content as a string
3. The program takes those inputs to create a struct which stores the note title, content, and the timestamp at its creation
4. The user inputs the todo text
5. The program takes the todo text input to create another struct which stores the todo text (without any title)
6. The program displays messages to confirm the note’s title and its content from the inputs
7. The program displays a message to confirm the todo
8. The program displays a message to notify the user that it’s saving the note
9. The program attempts to save the inputs as a json file with json field names according to the struct tags given in the code
10. The program displays the message that it saves the file successfully
11. The program repeat the same process from 8. for the todo (the todo’s file name is already hard-coded in the program and can’t be changed)

A Discord bot that translates regular text into UwU-speak.

• uwu*that – Uwuify a message in chat. Reply to a message to uwuifiy it.
• uwu*this – Uwuify text. The rest of the message will be uwuified.
• uwu*me – Follow the sender and translate everything that they say in the current channel.
• uwu*stop [where] – Stop following the sender. Optionally set where to “channel”, “server”, or “everywhere” to stop following in the current channel, current server, or in all of Discord, respectively. Defaults to “channel”.
• uwu*stop_everyone [where] – Stop following everyone in the current channel or server. Optionally set where to “channel” or “server” to specify where to stop following. Defaults to “channel”. Requires “Manage Messages” permission.
• uwu*them <user> – Follow a specified user and translate everything that they say in the current channel. Requires “Manage Messages” permission. Use the command again to stop following.

The bot can be configured through a JSON configuration file, located at /opt/UwuBot/appsettings.Production.json by default.
You must add your Discord token here before using the bot.
If you are using the the install script, then a default configuration file will be provided for you.
To create a configuration file manually, start with this template:

{
  "DiscordAuth": {
    "DiscordToken": "YOUR DISCORD TOKEN HERE",
  },
  "BotOptions": {
    "CommandPrefixes": [ "uwu*" ]
  },
  "UwuOptions": {
    "AppendUwu": true,
    "MakeCuteCurses": true
  }
}

The following options are available to customize the bot behavior:

To join the bot to a server, you must grant permissions integer 2048. This consists of:

• bot scope
• Send Messages permission

You must also grant the “Message Content” intent in the Discord Developer Portal.

• .NET 6+
• Windows, Linux, or MacOS. A version of Linux with SystemD (such as Ubuntu) is required to use the built-in install script and service definition.

Before you can run discord-uwu-bot, you need a Discord API Token.
You can get this token by creating and registering a bot at the Discord Developer Portal.
You can use any name or profile picture for your bot.
Once you have registered the bot, generate and save a Token.

For Ubuntu (or other SystemD-based Linux systems), an install script and service definition are provided.
This install script will create a service account (default uwubot), a working directory (default /opt/UwuBot), and a SystemD service (default uwubot).
This script can update an existing installation and will preserve the appsettings.Production.json file containing your Discord Token and other configuration values.

1. Compile the bot or download pre-built binaries.
2. Run sudo ./install.sh.
3. [First install only] Edit /opt/UwuBot/appsettings.Production.json and add your Discord token.
4. Run sudo systemctl start uwubot to start the bot.

For non-Ubuntu systems, manual setup is required.
The steps below are the bare minimum to run the bot, and do not include steps needed to create a persistent service.

1. Compile the bot or download pre-built binaries.
2. Edit appsettings.Production.json and add your Discord token.
3. Run dotnet DiscordUwuBot.Main.dll to start the bot.

The book list what I read since 2017

1. 유난한 도전. 경계를 부수는 사람들, 토스팀 이야기
2. 클린 애자일
3. 진짜 챗GPT 활용법
4. 이처럼 사소한 것들

1. 역전의 명수 난공불락의 1위를 뒤집은 창조적 추격자들의 비밀
2. 푸틴을 죽이는 완벽한 방법
3. 실리콘밸리의 잘나가는 변호사 레비 씨, 스티브 잡스의 골칫덩이 픽사에 뛰어들다!

1. 서울 자가에 대기업 다니는 김 부장 이야기 1 김 부장 편
2. 서울 자가에 대기업 다니는 김 부장 이야기 2 정 대리 · 권 사원 편
3. 서울 자가에 대기업 다니는 김 부장 이야기 3 송 과장 편
4. 때로는 행복 대신 불행을 택하기도 한다
5. 주식회사 르브론 제임스 억만장자 운동선수의 탄생
6. 행복을 파는 브랜드, 오롤리데이

1. 규칙없음
2. 바이러스 X

1. 아주 작은 습관의 힘
2. 그로스 해킹
3. 오베라는 남자
4. Design patterns by tutorials
5. 백종원의 장사 이야기
6. 딥워크
7. 연금술사
8. 슈독
9. 아몬드
10. 세상을 만드는 글자, 코딩
11. 셀트리오니즘

1. 홍콩산책
2. 1시간에 1권 퀀텀 독서법
3. 코딩을 지탱하는 기술
4. 당신 거기 있어줄래요
5. 한입에 웹 크롤링
6. 수축사회
7. 집 없이도 쉐어하우스로 제2의 월급 받는 사람들
8. 블록체인 무엇인가
9. 왜 세계의 절반은 굶주리는가
10. 우리 이제 낭만을 이야기합시다
11. 이십팔 독립선언
12. 침대부터 정리하라
13. 마케팅 천재가 된 맥스
14. Concurrency by Tutorials
15. 손정의 300년 왕국의 야망
16. 홍선표 기자의 써먹는 경제상식
17. 타이탄
18. 축구를 하며 생각한 것들
19. 사업을 한다는 것
20. 수상한 기록
21. Favorite magazine – We work together part1
22. 50대 사건으로 보는 돈의 역사
23. 꿈이 있으면 늙지 않는다
24. 데미안
25. 승려와 수수께끼

1. 미중전쟁 2권
2. 바깥은 여름
3. 청춘의 돈 공부
4. 옵션 B
5. 서른의 반격
6. 누워서 읽는 알고리즘
7. 알고리즘 라이프
8. 생각하는 늑대 타스케
9. 편의점 인간
10. 책 잘 읽는 방법
11. 82년생 김지영
12. 잠깐만 회사 좀 관두고 올게
13. 거래의 기술
14. 서른 살엔 미처 몰랐던 것들
15. 바람이 되고 싶었던 아이
16. 부자의 그릇
17. 청년 기업가 정신
18. 아마존, 세상의 모든 것을 팝니다
19. 파괴적 혁신
20. 문경수의 제주 과학 탐험
21. Favorite magazine – guest house

1. 오리지널스
2. 29살 생일 1년후 죽기로 결심했다
3. 커피드림
4. 나는 왜 정치를 하는가
5. 스타트업 전성시대
6. 고구려 4권
7. 고구려 5권
8. 소셜 코딩으로 이끄는 GitHub 실천기술
9. 데드하트
10. 예언
11. 에어비앤비 스토리
12. 남자의 물건
13. 언어의 온도
14. 명견만리(인구, 경제, 북한, 의료 편)
15. 인공지능 투자가 퀀트
16. 나미야 잡화점의 기적
17. 미중전쟁 1권

The Paho JavaScript Client is an MQTT browser-based client library written in Javascript that uses WebSockets to connect to an MQTT Broker.

The Paho project has been created to provide reliable open-source implementations of open and standard messaging protocols aimed at new, existing, and emerging applications for Machine-to-Machine (M2M) and Internet of Things (IoT).
Paho reflects the inherent physical and cost constraints of device connectivity. Its objectives include effective levels of decoupling between devices and applications, designed to keep markets open and encourage the rapid growth of scalable Web and Enterprise middleware and applications.

• Project Website: https://www.eclipse.org/paho
• Eclipse Project Information: https://projects.eclipse.org/projects/iot.paho
• Paho Javascript Client Page: https://eclipse.org/paho/clients/js/
• GitHub: https://github.com/eclipse/paho.mqtt.javascript
• Twitter: @eclipsepaho
• Issues: github.com/eclipse/paho.mqtt.javascript/issues
• Mailing-list: https://dev.eclipse.org/mailman/listinfo/paho-dev

A zip file containing the full and a minified version the Javascript client can be downloaded from the Paho downloads page

Alternatively the Javascript client can be downloaded directly from the projects git repository: https://raw.githubusercontent.com/eclipse/paho.mqtt.javascript/master/src/paho-mqtt.js.

Please do not link directly to this url from your application.

There are two active branches on the Paho Java git repository, master which is used to produce stable releases, and develop where active development is carried out. By default cloning the git repository will download the master branch, to build from develop make sure you switch to the remote branch: git checkout -b develop remotes/origin/develop

The project contains a maven based build that produces a minified version of the client, runs unit tests and generates it’s documentation.

To run the build:

$ mvn

The output of the build is copied to the target directory.

The client uses the Jasmine test framework. The tests for the client are in:

src/tests

To run the tests with maven, use the following command:

$ mvn test

The parameters passed in should be modified to match the broker instance being tested against.

Reference documentation is online at: http://www.eclipse.org/paho/files/jsdoc/index.html

The client should work in any browser fully supporting WebSockets, http://caniuse.com/websockets lists browser compatibility.

The included code below is a very basic sample that connects to a server using WebSockets and subscribes to the topic World, once subscribed, it then publishes the message Hello to that topic. Any messages that come into the subscribed topic will be printed to the Javascript console.

This requires the use of a broker that supports WebSockets natively, or the use of a gateway that can forward between WebSockets and TCP.

// Create a client instance
var client = new Paho.MQTT.Client(location.hostname, Number(location.port), "clientId");

// set callback handlers
client.onConnectionLost = onConnectionLost;
client.onMessageArrived = onMessageArrived;

// connect the client
client.connect({onSuccess:onConnect});


// called when the client connects
function onConnect() {
  // Once a connection has been made, make a subscription and send a message.
  console.log("onConnect");
  client.subscribe("World");
  message = new Paho.MQTT.Message("Hello");
  message.destinationName = "World";
  client.send(message);
}

// called when the client loses its connection
function onConnectionLost(responseObject) {
  if (responseObject.errorCode !== 0) {
    console.log("onConnectionLost:"+responseObject.errorMessage);
  }
}

// called when a message arrives
function onMessageArrived(message) {
  console.log("onMessageArrived:"+message.payloadString);
}

Previously the Client’s Namepsace was Paho.MQTT, as of version 1.1.0 (develop branch) this has now been simplified to Paho.
You should be able to simply do a find and replace in your code to resolve this, for example all instances of Paho.MQTT.Client will now be Paho.Client and Paho.MQTT.Message will be Paho.Message.

A brainfuck compiler written in Haskell

• Languages: Haskell
• Packages: Parsec

I wrote a blog post about this project

You need to have cabal, Haskell installed. Then run the following commands To run the program you need gcc for the C version and SPIM for the MIPS version

# clone the repo and move to it
git clone https://github.com/tttardigrado/hsfuck
cd hsfuck

# build the project using cabal
cabal build

# optionally move the binary into another location with
# cp ./path/to/binary .

# run the compiler
# (fst argument is compilation target mode. Either c or mips)
# (snd argument is the path of the src file)
# (trd argument is the path of the output file)
./hsfuck c test.bf test.c

# compile and run the C code
gcc test.c
./a.out

Suggestion: Add the following snippets to your .bashrc

# compile brainfuck to c and then to binary
bfC()
{
    ./hsfuck c $1 /tmp/ccode.c
    gcc /tmp/ccode.c -o $2
}

# simulate as MIPS (using SPIM)
bfMIPS()
{
    ./hsfuck mips $1 /tmp/mipscode.mips
    spim -file /tmp/mipscode.mips
}

• + increment the value of the current cell
• - decrement the value of the current cell
• » right shift the value of the current cell
• « left shift the value of the current cell
• > move the tape one cell to the right
• < move the tape one cell to the left
• . print the value of the current cell as ASCII
• , read the value of an ASCII character from stdin to the current cell
• : print the value of the current cell as an integer
• ; read an integer from stdin to the current cell
• [c] execute c while the value of the cell is not zero
• # print debug information

• Brainfuck
  • An introduction to programming in BF
  • BF is Turing-complete
• Optimizations
  • Brainfuck optimization strategies
  • BFC Optimizations
  • An Optimising BF Compiler
  • Even More BF Optimisations

• 0 set the cell to 0
• » and « -> right and left shifts
• Add more print and read options (integer)
• remove register
• compile to MIPS
• Add debug to MIPS target
• Test MIPS and C output
• Add compilation target flag
• Add commands documentation
• Add references

Google App Engine provides a Cron service for logging daily Google Search Console(GSC): Search Analytics data to BigQuery for use in
Google Data Studio or for separate analysis beyond 3 months.

This script runs daily and pulls data as specified in config.py file to BigQuery. There is little to configure without some programming experience.
Generally, this script is designed to be a set-it-and-forget-it in that once deployed to app engine, you should be able to add your service account
email as a full user to any GSC project and the Search Analytics data will be logged daily to BigQuery. By default the data is set to pull from GSC 7 days earler every day
to ensure the data is available.

• Note: This script should be deployed on the Google Account with access to your GSC data to ensure it is available to Google Data Studio
• Note: This script has not been widely tested and is considered a POC. Use at your own risk!!!
• Note: This script only works for Python 2.7 which is a restriction for GAE currently

More installation details located here.
Developed by Technical SEO Agency, Adapt Partners

The overview for configuring and running this sample is as follows:

• If you don’t already have one, create a
  Google Account.

• Create a Developers Console project.

  1. Install (or check that you have previously installed)
     • git
     • Python 2.7
     • Python pip
     • Google Cloud SDK
  2. Enable the BigQuery API
  3. Enable the GSC API
  4. Enable Project Billing

To clone the GitHub repository to your computer, run the following command:

$ git clone https://github.com/jroakes/gsc-logger.git

Change directories to the gsc-logger directory. The exact path
depends on where you placed the directory when you cloned the sample files from
GitHub.

$ cd gsc-logger

1. Go to https://console.cloud.google.com/projectselector/iam-admin/serviceaccounts and create a Service Account in your project.
2. Download the json file.
3. Upload replacing the file in the credentials directory.

1. Configure the gcloud command-line tool to use the project your Firebase project.

$ gcloud config set project <your-project-id>

2. Change directory to appengine/

$ cd appengine/

3. Install the Python dependencies

$ pip install -t lib -r requirements.txt

4. Create an App Engine App

$ gcloud app create

5. Deploy the application to App Engine.

$ gcloud app deploy app.yaml \cron.yaml \index.yaml

Go to the Task Queue tab in AppEngine and
click on Cron Jobs to verify that the daily cron is set up correctly. The job should have a Run Now button next to it.

Once deployed, you should be able to load your GAE deployment url in a browser and see a screen that lists your service account email and also attached GSC sites. This screen will also list the last cron save date for each site
that you have access to.

Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.