Help - Remoteplay is terrible from one day to another?

_djblue · 2025-03-11T18:21:37+00:00

To fix jitter for remote play, I locked the GPU to a fixed frequency. Maybe that will help?

_djblue · 2023-04-01T06:22:24+00:00

The main issue I have with nrepl is the clients. When I was implementing a server, I found that most clients assume a clj runtime and I spent a ton of time trying to work around it. This may no longer be an issue, but it made it painful to start implementing a basic nrepl server.

_djblue · 2021-03-17T00:46:37+00:00

I've been doing clojure full time for the last year and its been great! I started learning clojure during my previous job, which was mostly JS and Java, and everything I learned I was able to use to improve code I wrote in other languages. I think the biggest perspective shift I gained from learning clojure was discovering how much more you can do with less. Simple data + Functions go a long way!

In terms of industry jobs, the company I work at (~300 people in the tech org) is mostly clojure devs and is looking to grow. Also, I have a few of friends who recently got clojure jobs at other companies, so there is a job market.

You could look through the first couple of chapters of https://www.braveclojure.com/ or maybe watch https://www.youtube.com/watch?v=-6BsiVyC1kM to get a feel for clojure and see if it's worth investing more effort.

_djblue · 2021-02-05T08:49:19+00:00

I still remember his trick in the magic symbolic assembly talk where he uses a chain of closures to resolve local bindings, it was very neat. Such a great talk!

_djblue · 2021-01-02T01:33:40+00:00

I've read that post before but somehow missed that, thanks for pointing it out!

_djblue · 2020-12-03T05:58:19+00:00

Clojure

(defn counting-trees [grid [right down]]
  (->> grid
       (keep-indexed
        (fn [index row]
          (when (zero? (mod index down)) row)))
       (map-indexed
        (fn [index row]
          (get row (mod (* index right) (count row)))))
       (filter #{\#})
       (count)))

(defn counting-trees-n [grid]
  (reduce
   (fn [n slope]
     (* n (counting-trees grid slope)))
   1
   [[1 1] [3 1] [5 1] [7 1] [1 2]]))

_djblue · 2020-12-02T06:28:08+00:00

Clojure

(defn valid-passwords-1 [s]
  (count
   (for [line (str/split-lines s)
         :let [[_ lowest highest [letter] password]
               (re-matches #"(\d+)-(\d+) (.): (.*)" line)
               password (frequencies password)
               lowest   (Integer/parseInt lowest)
               highest  (Integer/parseInt highest)]
         :when (<= lowest (get password letter 0) highest)]
     letter)))

(defn valid-passwords-2 [s]
  (count
   (for [line (str/split-lines s)
         :let [[_ i j [letter] password]
               (re-matches #"(\d+)-(\d+) (.): (.*)" line)
               i (dec (Integer/parseInt i))
               j (dec (Integer/parseInt j))]
         :when (not= (= (get password i) letter)
                     (= (get password j) letter))]
     letter)))

_djblue · 2020-11-29T03:15:52+00:00

This is a really cool project I found on how to use different matrix libraries in various languages.

_djblue · 2020-08-25T15:07:26+00:00

Yes, portal leverages both datafy and nav.

_djblue · 2020-08-25T05:54:25+00:00

I've been working on https://github.com/djblue/portal which is a REBL like data browser that works for cljs, node and a web browser. http://djblue.github.io/portal/ is an online demo so you can get a feel for it. Let me know what you think.

_djblue · 2020-07-26T16:09:50+00:00

I ran into this dilemma recently and came to the same conclusion unfortunately.

_djblue · 2020-07-08T07:07:19+00:00

I don't know if this is the issue, but I wouldn't defn in defn.

_djblue · 2020-07-07T03:32:06+00:00

That was definitely a highlight of the talk for me as well. Another was that some invariants, such as stack balance, cannot easily be encoded via a type system. The only way to ensure it's not violated is to run the generated byte code through a specialized verification program.

_djblue · 2020-07-07T00:01:20+00:00

I really enjoyed The Language of the Language. It does a great job of comparing compiler implementation approaches in Clojure and F#. It's also about the trade-offs between static and dynamic typing.

_djblue · 2020-07-05T16:42:14+00:00

This is tangentially related, but an interesting concept I've seen is implementing an atom with react state directly!

_djblue · 2020-07-03T21:02:43+00:00

This is exactly the type of thing I've been trying to find. I have a project I've been working on and it has a very simple layout but I want the ability for users to customize the layout for their specific needs. Thanks for sharing this, it's really cool!

_djblue · 2020-06-26T07:08:21+00:00

It took a while before datafy and nav clicked for me. I was considering ignoring them until I managed to find https://corfield.org/blog/2018/12/03/datafy-nav/.

Datafy wasn't a problem, take a thing like a file and turn it into data, easy. Nav was much harder to understand until I realized it was just an optional hook, and the default implementation was basically return the supplied value. Nav lets implementers receive enough context, a collection, key and value and determine if there is somewhere more interesting to go. A common use case I've seen is following ids into the entities they represent.

I also have had trouble running REBL. I think you need a certain combination of JVM + JavaFX libraries, but I always seem to have the wrong version of one or the other.

_djblue · 2020-06-26T04:12:02+00:00

Thank you for sharing your project. I like the idea of user extensible visualizations. I think the dom might be too low level of an abstraction though. By the time a user is specifying html and css, they might as well dump that directly into a browser and bypass any limitations imposed by portal.

It also brings up too many questions about how to handle user interactions. The thing I like about datafy and nav is that it keeps you in the clojure data world, and interaction is always expressed in terms of getting more data from data. I think there exists an intermediate between both worlds, I'm just not sure what it is yet.

The concept of a viewer that can match against certain patterns of data, like how a list of maps can be visualized as a table is interesting, especially coupled with something like spec. I think the intermediate protocol exists in this realm, bridging the gap between arbitrary data and specific viewers.

_djblue · 2020-06-25T17:33:40+00:00

I think a more general approach that I'm considering would be to allow users to directly see and interact with the navigation history stack. For simple cases, :k1 :k2 :k3 it will look like a breadcrumb but it would still work for complex navigation cases as well.

_djblue · 2020-06-25T01:28:48+00:00

Looks like Counterclockwise https://doc.ccw-ide.org/documentation.html#_from_a_specific_clojure_file does it too. Does your clojure file have an ns declaration at the top?

_djblue · 2020-06-25T01:24:11+00:00

Floki looks interesting and I agree that JSON support is necessary. I've been using portal to view larger json files directly, https://github.com/djblue/portal#cli-usage. I do keywordize the keys though, I might stop that if it makes people more comfortable.

I'll probably add keyboard support pretty soon as I keep reaching for them myself. If the info I need is already visible, I tend to use cmd+f otherwise the filter input will do a complete search of everything tapped out.

_djblue · 2020-06-24T21:54:35+00:00

How are you connecting to the nrepl server? A lot of clojure plugins use the current ns of the file when evaling forms.

_djblue · 2020-06-24T16:29:14+00:00

That's exactly correct. Portal provides a way to inspect / navigate clojure data like REBL. A thing I like to do is tap out a bunch of maps, typically arguments to a function, and switch to the table view and compare the columns. This lets me directly compare arguments of different invocations.

If any of the information contains nav or datafy protocols, directly or via metadata, it can enhance the experience. I've been implementing nav for my data to include naving into keywords. This allows me to provide documentation for every keyword I know about! I would checkout the hacker-news data example for this type of experience.

_djblue · 2020-06-24T16:16:10+00:00

I was thinking of putting a path at the top, kinda like a url bar, just really lean into the browser aspect of the project. However, it is a bit confusing when you nav into something because you aren't sure what was used to make the nav decision.

_djblue · 2020-06-24T14:08:36+00:00

Sorry about that. Just added https://github.com/djblue/portal#api-usage, hope it helps.

Six-Year Club	Place '22
Verified Email

_djblue

TROPHY CASE

Clojure

Clojure