The OFFICIAL programming thread

Gustaf

@kilemall said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

@jam said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The Code civil du Québec :

http://www.studenthousingguide.co.uk/wp-content/uploads/2017/08/Room.jpg

Now, the Criminal Code of Canada :

http://www.personal.psu.edu/afr3/blogs/siowfa13/RCAT-100MessyRoom.jpg

So English Common Law is a bit messy like a college kids room, but Code Civil du Quebec is like a girl’s bedroom?

Tidy as fuck.

I googled “tidy rooms” and all I got was girlie rooms :/

Google understands.

Everything you were up to.

Pedo-Lob

Stu

@lob12 said in The OFFICIAL programming thread:

The modern version has been rewritten 2-3 times in the last 150 +/- years and it was heavily influenced by France’s Code Napoleon.

I understand Napoleonic Code leans towards a “guilty until proven innocent,” view. Does Quebec’s civil code also do that?

Lob12

@stu said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The modern version has been rewritten 2-3 times in the last 150 +/- years and it was heavily influenced by France’s Code Napoleon.

I understand Napoleonic Code leans towards a “guilty until proven innocent,” view. Does Quebec’s civil code also do that?

No, but the presumption of innocence is more of a criminal law concept anyway. I don’t know French criminal law at all tbh but I’m quite sure they have something that is very similar. Here is a quote from wiki :

“In France, article 9 of the Declaration of the Rights of Man and of the Citizen of 1789, which has force as constitutional law, begins: “Any man being presumed innocent until he has been declared guilty …” The Code of Criminal Procedure states in its preliminary article that “any person suspected or prosecuted is presumed innocent for as long as their guilt has not been established”[6] and the jurors’ oath repeats this assertion (article 304; note that only the most serious crimes are tried by jury in France). However, there exists a popular misconception that under French law, the accused is presumed guilty until proven innocent.”

In Canada, presumption of innocence in criminal matters is guaranteed by section 11(d) of the Canadian Charter of Rights and Freedoms.

Like I said before, the Code civil applies to non-criminal matters (i.e. tort, contract laws) where the burden of proof basically always falls (unless you were able to demonstrate the existence of a legal presumption) to the party who is making the allegations. Example : Jam pushed me down the staircases and I’m suing him for damages (classic tort case). Well I have to prove that Jam pushed me down the staircase and demonstrate the damages I suffered. The burden of proof I have to satisfy here is not “beyond a reasonable doubt” but more according to a “balance of probabilities”.

What you do find a lot in the civil code is the notion of Good faith vs Bad faith. And one of the first articles of the Book of Evidence states that “Good faith is always presumed, unless the law expressly requires that it be proved.” So if you’re accusing someone of being a lying scumbag in any kind of litigation, or if you pretend that someone’s actions were purposely designed to hurt you in any way, well its up to you to prove it.

Kilemall

I don’t think Canadian OT boards would be fun at all with that kind of proof required!

My Dad tried to get me interested in machine code / assembly programming when I was grade school. He’d bought this thing called the Microprofessor and was happily learning about how setting bits in code translated directly to the hardware.

It wasn’t too long before he was building custom hardware and programming eeproms to control lighting for productions at the theatre where he was the Technical Director.

Anyway, I listened dutifully to every he excitedly tried to teach me on the subject but really had zero interest in it myself. However, just now, 4 decades later, I had a requirement to store cartesian coordinates as a single unsigned integer and boy I’m glad I understood enough of what he taught me to not be put off by things like two’s-complement and bit shifting/masking.

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

Gators1

@hog said in The OFFICIAL programming thread:

My Dad tried to get me interested in machine code / assembly programming when I was grade school. He’d bought this thing called the Microprofessor and was happily learning about how setting bits in code translated directly to the hardware.

It wasn’t too long before he was building custom hardware and programming eeproms to control lighting for productions at the theatre where he was the Technical Director.

Anyway, I listened dutifully to every he excitedly tried to teach me on the subject but really had zero interest in it myself. However, just now, 4 decades later, I had a requirement to store cartesian coordinates as a single unsigned integer and boy I’m glad I understood enough of what he taught me to not be put off by things like two’s-complement and bit shifting.

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
	var mask_high = 2 ^ BITS_PER_DIMENSION - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

???

Next time please post tits.

@gators1 said in The OFFICIAL programming thread:

???

I’m making a game with a map where everything is a at a position that is a grid reference away from the center. So player X might be at grid reference (-2, 1), and there might be a big impassable rock at (1, 0).

However, the pathfinding API (the library that tells me how the player moves from one location to another,) requires that each point on the map be expressed/id’d as a single number greater than zero.

So, how do you take something like (-2,1) or (1,0) and create a single, unsigned, numbers from them like 3 or 14 and then later take 3 or 14 and turn it back into (-2,1) and (1,0)? That’s what my code does.

Oh, and:

Gators1

@hog said in The OFFICIAL programming thread:

@gators1 said in The OFFICIAL programming thread:

???

I’m making a game with a map where everything is a at a position that is a grid reference away from the center. So player X might be at grid reference (-2, 1), and there might be a big impassable rock at (1, 0).

However, the pathfinding API (the library that tells me how the player moves from one location to another,) requires that each point on the map be expressed as a single number greater than zero.

So, how do you take something like (-2,1) or (1,0) and create a single, unsigned, numbers from them like 3 or 14 and then later take 3 or 14 and turn it back into (-2,1) and (1,0)? That’s what my code does.

Wait, did Jerry hire you to work on his game? You know it’s a scam, right?

rote7

@hog said in The OFFICIAL programming thread:

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

My bit shifting days are but a remote memory so you may have to help me understand how

var id = col_shifted + row_normalized

does not overwrite the previously stored pattern in col_shifted.

Blanks

@hog said in The OFFICIAL programming thread:

Oh, and:

Maybe you should program this forum. That’s award winning content right there.

@rote7 said in The OFFICIAL programming thread:

@hog said in The OFFICIAL programming thread:

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

My bit shifting days are but a remote memory so you may have to help me understand how

var id = col_shifted + row_normalized

does not overwrite the previously stored pattern in col_shifted.

Sure, it’s a combination of three things:

they’ve both been converted to unsigned ints (normalized) so the highest bit isn’t set in either number
and the lowest bits of col_shifted are 0 because of the shift
row_normalized only has the lowest bits set because the size of the number is constrained to +/- MAX_EXTENTS

So, even with maximum values for row and column, the addition is like:

00001100 col_shifted +
00000011 row_normalized =
--------
00001111

Edit: by the way, the code i posted earlier was just a proof of concept. My actual use case (which I’ve since coded) has three dimensions. It is using 22 bits (9 + 9 + 4) for a map of 512x512x16 possible locations.

This post is deleted!

Pakoon

tigger

@pakoon said in The OFFICIAL programming thread:

Jajajaja!

rote7

Time for my favorite frownie: m(

rote7

The Case Against SQL - Slashdot

Long-time Slashdot reader RoccamOccam shares "an interesting take on SQL and its issues from Jamie Brandon (who describes himself as an independent researcher who's built database engines, query planners, compilers, developer tools and interfaces). It's title? "Against SQL." The relational model...

Interesting article, I didn’t know that

“The SQL spec (part 2 = 1732) pages is more than twice the length of the Javascript 2021 spec (879 pages), almost matches the C++ 2020 spec (1853) pages and contains 411 occurrences of ‘implementation-defined’, occurrences which include type inference and error propagation.”

Sweet jesus, double the length of the JS specs…

One SQL problem that I couldn’t solve so far is finding a good way to use the output of a single column query (multiple rows, result count must be flexible) as headers and/or fields for a subsequent query.

Kilemall

@rote7 said in The OFFICIAL programming thread:

The Case Against SQL - Slashdot

Long-time Slashdot reader RoccamOccam shares "an interesting take on SQL and its issues from Jamie Brandon (who describes himself as an independent researcher who's built database engines, query planners, compilers, developer tools and interfaces). It's title? "Against SQL." The relational model...

Interesting article, I didn’t know that

“The SQL spec (part 2 = 1732) pages is more than twice the length of the Javascript 2021 spec (879 pages), almost matches the C++ 2020 spec (1853) pages and contains 411 occurrences of ‘implementation-defined’, occurrences which include type inference and error propagation.”

Sweet jesus, double the length of the JS specs…

One SQL problem that I couldn’t solve so far is finding a good way to use the output of a single column query (multiple rows, result count must be flexible) as headers and/or fields for a subsequent query.

Dynamic DB-driven filter query? Sounds like a specific SQL client function to me.

rote7

@Kilemall Yes, that was my first idea too. My goal is to replace a whole lot of client logic with a set of queries/subqueries and/or joins. I am looking for a pivot mechanism to transform a set of column(s) into rows.

E.g. turn

col_1 | col_2
param_1 | value_1
param_2 | value_2
param_foo | value_fo

into a dynamic DB operation that delivers a result like the client generated query “SELECT * FROM table WHERE param_1 = value_1 AND param_2 = value_2 AND param_foo = value_foo” without all the string concatenation, input scrubbing etc. pp. going on in the client.

Gators1

@rote7 said in The OFFICIAL programming thread:

The Case Against SQL - Slashdot

Long-time Slashdot reader RoccamOccam shares "an interesting take on SQL and its issues from Jamie Brandon (who describes himself as an independent researcher who's built database engines, query planners, compilers, developer tools and interfaces). It's title? "Against SQL." The relational model...

Interesting article, I didn’t know that

“The SQL spec (part 2 = 1732) pages is more than twice the length of the Javascript 2021 spec (879 pages), almost matches the C++ 2020 spec (1853) pages and contains 411 occurrences of ‘implementation-defined’, occurrences which include type inference and error propagation.”

Sweet jesus, double the length of the JS specs…

One SQL problem that I couldn’t solve so far is finding a good way to use the output of a single column query (multiple rows, result count must be flexible) as headers and/or fields for a subsequent query.

I think you need to do it as a stored procedure if I remember right and using the PIVOT function. Basically instead of defining the static columns as in the base function, you dynamically insert them in the stored procedure. If you are doing this as part of another code project, you could do the same by just assembling the text of the SQL script to sent dynamically (e.g. “SELECT “& [column name varIable]&” FROM TABLE_NAME;”