plasmid

How do you get 117 non-self node when there are 200 nodes and 40 self nodes? (well, plus a couple of nodes of buffer between you and where the enemy might lurk) If I were to use 160, then a line of code that uses the principle I described but goes backwards from -1 to -160 instead of counting forwards (to find the first line of enemy code instead of the last line) and assigns it to the variable "a" would be .... a neg(int(pow(sum(pow(mult(-1,div(num(-1),num(-1))),4),pow(mult(-2,div(num(-2),num(-2))),4),pow(mult(-3,div(num(-3),num(-3))),4),pow(mult(-4,div(num(-4),num(-4))),4),pow(mult(-5,div(num(-5),num(-5))),4),pow(mult(-6,div(num(-6),num(-6))),4),pow(mult(-7,div(num(-7),num(-7))),4),pow(mult(-8,div(num(-8),num(-8))),4),pow(mult(-9,div(num(-9),num(-9))),4),pow(mult(-10,div(num(-10),num(-10))),4),pow(mult(-11,div(num(-11),num(-11))),4),pow(mult(-12,div(num(-12),num(-12))),4),pow(mult(-13,div(num(-13),num(-13))),4),pow(mult(-14,div(num(-14),num(-14))),4),pow(mult(-15,div(num(-15),num(-15))),4),pow(mult(-16,div(num(-16),num(-16))),4),pow(mult(-17,div(num(-17),num(-17))),4),pow(mult(-18,div(num(-18),num(-18))),4),pow(mult(-19,div(num(-19),num(-19))),4),pow(mult(-20,div(num(-20),num(-20))),4),pow(mult(-21,div(num(-21),num(-21))),4),pow(mult(-22,div(num(-22),num(-22))),4),pow(mult(-23,div(num(-23),num(-23))),4),pow(mult(-24,div(num(-24),num(-24))),4),pow(mult(-25,div(num(-25),num(-25))),4),pow(mult(-26,div(num(-26),num(-26))),4),pow(mult(-27,div(num(-27),num(-27))),4),pow(mult(-28,div(num(-28),num(-28))),4),pow(mult(-29,div(num(-29),num(-29))),4),pow(mult(-30,div(num(-30),num(-30))),4),pow(mult(-31,div(num(-31),num(-31))),4),pow(mult(-32,div(num(-32),num(-32))),4),pow(mult(-33,div(num(-33),num(-33))),4),pow(mult(-34,div(num(-34),num(-34))),4),pow(mult(-35,div(num(-35),num(-35))),4),pow(mult(-36,div(num(-36),num(-36))),4),pow(mult(-37,div(num(-37),num(-37))),4),pow(mult(-38,div(num(-38),num(-38))),4),pow(mult(-39,div(num(-39),num(-39))),4),pow(mult(-40,div(num(-40),num(-40))),4),pow(mult(-41,div(num(-41),num(-41))),4),pow(mult(-42,div(num(-42),num(-42))),4),pow(mult(-43,div(num(-43),num(-43))),4),pow(mult(-44,div(num(-44),num(-44))),4),pow(mult(-45,div(num(-45),num(-45))),4),pow(mult(-46,div(num(-46),num(-46))),4),pow(mult(-47,div(num(-47),num(-47))),4),pow(mult(-48,div(num(-48),num(-48))),4),pow(mult(-49,div(num(-49),num(-49))),4),pow(mult(-50,div(num(-50),num(-50))),4),pow(mult(-51,div(num(-51),num(-51))),4),pow(mult(-52,div(num(-52),num(-52))),4),pow(mult(-53,div(num(-53),num(-53))),4),pow(mult(-54,div(num(-54),num(-54))),4),pow(mult(-55,div(num(-55),num(-55))),4),pow(mult(-56,div(num(-56),num(-56))),4),pow(mult(-57,div(num(-57),num(-57))),4),pow(mult(-58,div(num(-58),num(-58))),4),pow(mult(-59,div(num(-59),num(-59))),4),pow(mult(-60,div(num(-60),num(-60))),4),pow(mult(-61,div(num(-61),num(-61))),4),pow(mult(-62,div(num(-62),num(-62))),4),pow(mult(-63,div(num(-63),num(-63))),4),pow(mult(-64,div(num(-64),num(-64))),4),pow(mult(-65,div(num(-65),num(-65))),4),pow(mult(-66,div(num(-66),num(-66))),4),pow(mult(-67,div(num(-67),num(-67))),4),pow(mult(-68,div(num(-68),num(-68))),4),pow(mult(-69,div(num(-69),num(-69))),4),pow(mult(-70,div(num(-70),num(-70))),4),pow(mult(-71,div(num(-71),num(-71))),4),pow(mult(-72,div(num(-72),num(-72))),4),pow(mult(-73,div(num(-73),num(-73))),4),pow(mult(-74,div(num(-74),num(-74))),4),pow(mult(-75,div(num(-75),num(-75))),4),pow(mult(-76,div(num(-76),num(-76))),4),pow(mult(-77,div(num(-77),num(-77))),4),pow(mult(-78,div(num(-78),num(-78))),4),pow(mult(-79,div(num(-79),num(-79))),4),pow(mult(-80,div(num(-80),num(-80))),4),pow(mult(-81,div(num(-81),num(-81))),4),pow(mult(-82,div(num(-82),num(-82))),4),pow(mult(-83,div(num(-83),num(-83))),4),pow(mult(-84,div(num(-84),num(-84))),4),pow(mult(-85,div(num(-85),num(-85))),4),pow(mult(-86,div(num(-86),num(-86))),4),pow(mult(-87,div(num(-87),num(-87))),4),pow(mult(-88,div(num(-88),num(-88))),4),pow(mult(-89,div(num(-89),num(-89))),4),pow(mult(-90,div(num(-90),num(-90))),4),pow(mult(-91,div(num(-91),num(-91))),4),pow(mult(-92,div(num(-92),num(-92))),4),pow(mult(-93,div(num(-93),num(-93))),4),pow(mult(-94,div(num(-94),num(-94))),4),pow(mult(-95,div(num(-95),num(-95))),4),pow(mult(-96,div(num(-96),num(-96))),4),pow(mult(-97,div(num(-97),num(-97))),4),pow(mult(-98,div(num(-98),num(-98))),4),pow(mult(-99,div(num(-99),num(-99))),4),pow(mult(-100,div(num(-100),num(-100))),4),pow(mult(-101,div(num(-101),num(-101))),4),pow(mult(-102,div(num(-102),num(-102))),4),pow(mult(-103,div(num(-103),num(-103))),4),pow(mult(-104,div(num(-104),num(-104))),4),pow(mult(-105,div(num(-105),num(-105))),4),pow(mult(-106,div(num(-106),num(-106))),4),pow(mult(-107,div(num(-107),num(-107))),4),pow(mult(-108,div(num(-108),num(-108))),4),pow(mult(-109,div(num(-109),num(-109))),4),pow(mult(-110,div(num(-110),num(-110))),4),pow(mult(-111,div(num(-111),num(-111))),4),pow(mult(-112,div(num(-112),num(-112))),4),pow(mult(-113,div(num(-113),num(-113))),4),pow(mult(-114,div(num(-114),num(-114))),4),pow(mult(-115,div(num(-115),num(-115))),4),pow(mult(-116,div(num(-116),num(-116))),4),pow(mult(-117,div(num(-117),num(-117))),4),pow(mult(-118,div(num(-118),num(-118))),4),pow(mult(-119,div(num(-119),num(-119))),4),pow(mult(-120,div(num(-120),num(-120))),4),pow(mult(-121,div(num(-121),num(-121))),4),pow(mult(-122,div(num(-122),num(-122))),4),pow(mult(-123,div(num(-123),num(-123))),4),pow(mult(-124,div(num(-124),num(-124))),4),pow(mult(-125,div(num(-125),num(-125))),4),pow(mult(-126,div(num(-126),num(-126))),4),pow(mult(-127,div(num(-127),num(-127))),4),pow(mult(-128,div(num(-128),num(-128))),4),pow(mult(-129,div(num(-129),num(-129))),4),pow(mult(-130,div(num(-130),num(-130))),4),pow(mult(-131,div(num(-131),num(-131))),4),pow(mult(-132,div(num(-132),num(-132))),4),pow(mult(-133,div(num(-133),num(-133))),4),pow(mult(-134,div(num(-134),num(-134))),4),pow(mult(-135,div(num(-135),num(-135))),4),pow(mult(-136,div(num(-136),num(-136))),4),pow(mult(-137,div(num(-137),num(-137))),4),pow(mult(-138,div(num(-138),num(-138))),4),pow(mult(-139,div(num(-139),num(-139))),4),pow(mult(-140,div(num(-140),num(-140))),4),pow(mult(-141,div(num(-141),num(-141))),4),pow(mult(-142,div(num(-142),num(-142))),4),pow(mult(-143,div(num(-143),num(-143))),4),pow(mult(-144,div(num(-144),num(-144))),4),pow(mult(-145,div(num(-145),num(-145))),4),pow(mult(-146,div(num(-146),num(-146))),4),pow(mult(-147,div(num(-147),num(-147))),4),pow(mult(-148,div(num(-148),num(-148))),4),pow(mult(-149,div(num(-149),num(-149))),4),pow(mult(-150,div(num(-150),num(-150))),4),pow(mult(-151,div(num(-151),num(-151))),4),pow(mult(-152,div(num(-152),num(-152))),4),pow(mult(-153,div(num(-153),num(-153))),4),pow(mult(-154,div(num(-154),num(-154))),4),pow(mult(-155,div(num(-155),num(-155))),4),pow(mult(-156,div(num(-156),num(-156))),4),pow(mult(-157,div(num(-157),num(-157))),4),pow(mult(-158,div(num(-158),num(-158))),4),pow(mult(-159,div(num(-159),num(-159))),4),pow(mult(-160,div(num(-160),num(-160))),4)),0.25))) At least I hope... I of course haven't been able to test it. If the enemy program is long enough, then the fourth root of (the sum of (its line numbers raised to the fourth power)) might be a little bit greater than the first line number, meaning that this will point to a line or two before the beginning of the enemy code. If this function works, you might even write the program so the first line calculates and moves a bomb to that spot: automatic win if you go first. Then have the rest of the program take reasonable actions in case you're going second.

Right with your intuition if not with those answers; Wilson got it. I usually make the real answer and the distractor be very different things. Indeed I am...

Some good answers, but something to notice about this one is that "I" am doing the work described in only the first two-and-a-half stanzas. The rest is part of a story, but the question is what "I" might then be, if not a smelter in the process of making munitions.

Good guess, but I don't think those ever reach a completely molten state.

Give me crude material That's taken from the ground My process then's ethereal As all is mixed around Heating up this witches' brew Would give me such delight Rock it back and forth a few More times to get it right The molten ore is still impure Although I've done my drill To say it's finished: premature More work to make a kill This carbon mixture's in a cast And hardens to a shell Or else there soon will come a blast To send the foul to hell

dms172's radar bomber program made me think of a way to make a really killer program. It would be theoretically possible to write this program, but in practice would be completely unwieldy. But I'll explain it anyways. The amazing part is that there will be ONE LINE of code that determines exactly (or very nearly) where the enemy code ends. This line would be the tough one to write. Briefly, the concept is that you use the num() command to look at each of the ~160 non-self nodes and determine whether or not they're bombs. You can do this with a function like div(num(n),num(n)-0.001) [call this F1(n)] to return 1 (or slightly more) if line n is a non-bomb and 0 if line n is a bomb (while avoiding divide by zero errors). You can take that term and just multiply it by n to make it return the line number if line n is a command or zero if line n is a bomb. mult(n,F1(n)) [call this F2(n)] So now how do you find the last line of code for the enemy program? One way to come close is by taking the sum over all n of F2(n) raised to a large power and then taking the log of that sum. In practice, the fourth power should be large enough to make the log base 4 of ( sum of all F2(n)^4 ) be pretty close to the maximum value of F2(n). The final function would look something like int(log(4,sum(pow(F2(1),4),pow(F2(2),4),pow(F2(3),4),... That's how to do it in principle, but it would mean you would have to write out all ~160 of those F2(n) terms by hand in that one line of code. (Of course there are probably ways of making Excel or Calc do it for you, or at least make it easier.) Once you've found out where your foe's last line of code is, it would be pretty straightforward to use a Brutus-esque bombing approach to wipe it out in short order. The only way to reliably foil such a program would be to make sure you have a 40-liner by making sure the last line of the 40 available lines of code is a non-bomb, and then have some code that transports the "real" program outside of the hot zone and executes it elsewhere sort of like zebra warrior. It would sort of have to be a program custom-built to avoid this program; I would imagine that most generic programs that don't know what's about to hit them would fall to this program if it were writeable.

That's the answer to this one. As for the one clue that didn't quite seem like it fit: Now that it's a few days after writing it, this one does seem to lack the "that's gotta be it" feel that should come with the solution to a good riddle. Maybe because it has some clues like the first three lines of the first and second stanzas, and the one above, that might be referring to just about anything. At any rate, a learning experience for the next one.

Closest one yet. The location is spot on for the graininess. But there's something else that seems like a much more natural fit for being less prone to smell than its friend who's held up by nails, is flat, and often prompts some painting.

Not mascara; I don't think it's grainy (but I'm a guy so no expert) and wouldn't really call it informal. Welcome, squareContacts; I usually write riddles that seem like they're describing one thing but are really describing something else and title them "I'm not a ..." whatever the more obvious of the two things is, so posterboard would be too much like the poster I rule out with the title. A wall would go against the last line. A kite fits most of the riddle, but leaves a hanging clue about why graininess would suit it well. For sandpaper, I'm not sure what it's "friend" would be that isn't held up by nails, and texturized paint wouldn't fit the first three lines. And remember that although there are many things that don't smell, the answer should have a reason why you would include such a line in a riddle describing the object. The biggest hints I left were in post 26 going over the clues and 29 about plainglazed and justkiknback's guesses.

I think there'd be a relatively straightforward way to kill the BM pretty reliably: write a program that's a jumper/bomber like ZW but calibrate the distance it jumps so that if it takes n turns to go through a jumping/bombing cycle then it will advance by 4n nodes per jump. If it doesn't get killed by the first wave of BM bombing then at the end of the cycle it will be in the same relative position compared to the BM bombing position and can survive another cycle. Of course, then I would just have to change the hard-coded BM bombing positions so that they're a random series instead of increments by 4. Unfortunately my work schedule will keep me from having any brain cells to spare until the weekend... also why I'm holding off on introducing Phronism to Dawkins.net until I hit a lighter block.

Yeah, I'll stick with that version; I wanted it to bomb all the way from 42 to 190 on the first round through and then increment. We'll see if it acts more like a legendary ancient warrior or more like a BM.

Don't know if it's been guessed already but... Plainglazed is spot on for interpreting the nails and most of the other clues. I see where you're going with the graininess part if it's a powder-type cosmetic... it's not what I was thinking of, but it does seem like it could be a reasonable interpretation for that clue. Juskiknback actually got what I had in mind for graininess but is missing the bit about nails.

Exactly

I hadn't intended for this to be a really serious riddle, but I guess it's following the tried and true BrainDen rule... Hopefully when it is solved you'll appreciate the humor of why it's called "I AM a subprime mortgage peddler"

The zebra does seem pretty slick. I hadn't really gone with the hopping approach myself just because I figured that the programs would be equally likely to get hit no matter where they are. If there were multiple pointers that had to initially start in a small area, that would be a different matter. The only thing I've noticed is that the probability of winning seems to depend mostly on how fast and furious you can be with throwing bombs. Great for Brutus Maximus, but it kind of leaves me thinking that there's a big penalty for creative programming. It might be nicer if, say, variable assignments took 1 ms, logical operations took 5 ms, writing a line took 100 ms, etc. to give them a chance to compete against a brute force machine. But that might be too complicated to program. What would you think about making it so that only line copying commands cost any time, and if you just execute a variable assignment or logical branchpoint or something you get to keep executing more lines of code until you do a write command?

There's no need to call for appointments at all Just walk right in through my door My cubicle sits in the corner position (And please, don't try to explore) Now just be discreet and take up a seat Deposit all that you make Aware of the cost: it might all be lost A risk you're willing to take On every exchange, the paper's arranged But please don't sign for this sale Clandestine, this deal a handshake will seal It's best not leaving a trail This business is dirty so leave in a hurry (But try to cover your rear) If wanting a call from the office just scrawl To leave a number right here

No one's really gone down the path I had in mind yet. I'm not sure if it's because there's so much misdirection, or if it's because there aren't any clues that really point towards the answer itself and it's only something that you could see fitting the riddle in retrospect. This one's been up for a couple of days now, so I guess I'll try doing like I did last time and see if listing the clues makes it clearer. - seems like it might easily fly if you lose your grip - not held up by nails (although its "friend" is) - stylish - paint is used to match colors - useful with "graininess" - informal - not prone to smell - flat - not confining

I see what you mean about complexity being detrimental. I tried to write an elaborate, self-diagnosing, self-repairing program, but in practice it only wins when it lucks out and wipes out the other program without having to regenerate . I wrote this in a spreadsheet so I could have comments (yeah, I know, such a nerdy programmer) Command Comment a sum(a,-3) Initially sets a=-3, then decrements 38 sum(-2,a) 1 bombs sum(num(-2),num(-1),num(0)) 10 -2 1 1 sees if the opening command set is intact: if so repeat, if not go to Regeneration sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 See if this copy of Regeneration is intact, if so then execute, if not then go to the next copy 4 -4 1 Copy the backup of the original plan back in its original position 4 -4 1 4 -4 1 sum(num(-7),num(-6),num(-5)) 10 -7 4 4 Sees if the original commands were resorted. If so, go to it. If not, go to the next copy of Regeneration a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 See if this copy of Regeneration is intact, if so then execute, if not then go to the next copy 4 -12 1 Copy the backup of the original plan back in its original position 4 -12 1 4 -12 1 sum(num(-15),num(-14),num(-13)) 10 -15 4 4 Sees if the original commands were resorted. If so, go to it. If not, go to the next copy of Regeneration a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 See if this copy of Regeneration is intact, if so then execute, if not then go to the next copy 4 -20 1 Copy the backup of the original plan back in its original position 4 -20 1 4 -20 1 sum(num(-23),num(-22),num(-21)) 10 -23 4 4 Sees if the original commands were resorted. If so, go to it. If not, go to the next copy of Regeneration a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 See if this copy of Regeneration is intact, if so then execute, if not then go to the next copy 4 -28 1 Copy the backup of the original plan back in its original position 4 -28 1 4 -28 1 sum(num(-31),num(-30),num(-29)) 10 -31 4 4 Sees if the original commands were resorted. If so, go to it. If not, go to the next copy of Regeneration a sum(a,-3) 38 sum(-2,a) -1 sum(num(-2),num(-1)) 5 -2 1 1 a sum(a,-37) If all copies of Regeneration failed, PANIC! BOMB LIKE MAD! 1 a -1 x x x da bomb [/codebox] Here's just the text that can be pasted into VNA a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 4 -4 1 4 -4 1 4 -4 1 sum(num(-7),num(-6),num(-5)) 10 -7 4 4 a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 4 -12 1 4 -12 1 4 -12 1 sum(num(-15),num(-14),num(-13)) 10 -15 4 4 a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 4 -20 1 4 -20 1 4 -20 1 sum(num(-23),num(-22),num(-21)) 10 -23 4 4 a sum(a,-3) 38 sum(-2,a) 1 sum(num(-2),num(-1),num(0)) 10 -2 1 1 sum(num(1),num(2),num(3),num(4),num(5),num(6),num(7)) 24 1 8 8 4 -28 1 4 -28 1 4 -28 1 sum(num(-31),num(-30),num(-29)) 10 -31 4 4 a sum(a,-3) 38 sum(-2,a) -1 sum(num(-2),num(-1)) 5 -2 1 1 a sum(a,-37) 1 a -1 x x x

I think I figured out what was going on. In the part where P2's turn takes place, there was the block // P2 now // // var zline = vna[lineTwo].toLowerCase(); // count the number of spaces in zline var chratloopy = 0; var numspaces = 0; while (chratloopy < zline.length) { if (zline.charAt(chratloopy) == " ") numspaces++; chratloopy++; } var newxline; paramz = zline.split(" "); valqa = doFunc(paramz[0]+"",lineTwo,2)*1; if (numspaces > 0) var valqb = doFunc(paramz[1]+"",lineTwo,1)*1; if (numspaces > 1) var valqc = doFunc(paramz[2]+"",lineTwo,1)*1; if (numspaces > 2) var valqd = doFunc(paramz[3]+"",lineTwo,1); if (numspaces > 3) var valqe = doFunc(paramz[4]+"",lineTwo,1); if (valqd != "!") valqd *= 1; But the third parameter to doFunc() is supposed to be the player's number, so it ought to be 2 instead of 1 // P2 now // // var zline = vna[lineTwo].toLowerCase(); // count the number of spaces in zline var chratloopy = 0; var numspaces = 0; while (chratloopy < zline.length) { if (zline.charAt(chratloopy) == " ") numspaces++; chratloopy++; } var newxline; paramz = zline.split(" "); valqa = doFunc(paramz[0]+"",lineTwo,2)*1; if (numspaces > 0) var valqb = doFunc(paramz[1]+"",lineTwo,2)*1; if (numspaces > 1) var valqc = doFunc(paramz[2]+"",lineTwo,2)*1; if (numspaces > 2) var valqd = doFunc(paramz[3]+"",lineTwo,2); if (numspaces > 3) var valqe = doFunc(paramz[4]+"",lineTwo,2); if (valqd != "!") valqd *= 1; Seems to be working as expected now. And Brutus Maximus is kicking some butt.

Weird, are you sure the two players' variables don't see each other? I'm getting some awfully unexpected stuff happening. I was pitting the Bomber against my Brutus Maximus and it looks like P2 is "seeing" P1's "a" variable when it's being set using the sum() command. Behavior switches depending on whether you have Brutus in P1 and Bomber in P2 (Bomber's a is always 4) or Bomber in P1 and Brutus in P2 (Brutus' a is always 4). Other weirdness is going on with the spacing between the bombs too (change the final x in each program to a number like 999 or 888 to make it clearer what's happening). Here's Brutus Maximus if you want to try it out. a sum(a,1) 38 sum(41,a) 1 37 sum(44,a) 1 36 sum(47,a) 1 35 sum(50,a) 1 34 sum(53,a) 1 33 sum(56,a) 1 32 sum(59,a) 1 31 sum(62,a) 1 30 sum(65,a) 1 29 sum(68,a) 1 28 sum(71,a) 1 27 sum(74,a) 1 26 sum(77,a) 1 25 sum(80,a) 1 24 sum(83,a) 1 23 sum(86,a) 1 22 sum(89,a) 1 21 sum(92,a) 1 20 sum(95,a) 1 19 sum(98,a) 1 18 sum(101,a) 1 17 sum(104,a) 1 16 sum(107,a) 1 15 sum(110,a) 1 14 sum(113,a) 1 13 sum(116,a) 1 12 sum(119,a) 1 11 sum(122,a) 1 10 sum(125,a) 1 9 sum(128,a) 1 8 sum(131,a) 1 7 sum(134,a) 1 6 sum(137,a) 1 5 sum(140,a) 1 4 sum(143,a) 1 3 sum(146,a) 1 2 sum(149,a) 1 1 sum(152,a) -38 x

That could fit all but the informal part Interesting. I had imagined that they would typically look formal, but a quick Google Images search shows that many need not be. I thought I had ruled out doors in general with the line about confinement not being my thing, but if a garden gate typically has a latch but no lock then it might work. It would certainly be possible to build it such that it swings shut if you let go. It could even fit the "smell" clue since it's at a garden. I think I'd call this an alternate answer that fits about as well as what I had in mind. I wouldn't want them to be grainy

Quick question: is there an upper limit on how many lines of code you get to write? It looks like it might be 42. And you wrote the html yourself? Awesome!

The graininess would seem un-aerodynamic for a glider or plane. Maybe... Roof tiles I think are usually held by nails, but even if not there's still the "fling" in the last couplet. While everyone's answers so far have not been prone to smell, there is a reason why such an odd clue is in there which the answer addresses.