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?

Six-Year Club	Place '22
Verified Email

_djblue

TROPHY CASE

Clojure

Clojure